Question

我正在努力在类之间使用变量和方法。例如，让我们只关注变量。我有两个班级，Foo和Bar。我在名为Foo的{{1}}中不断更改变量。如何从类number访问此变量？总会只有Bar类的一个实例。

Bar

我可以想到几个选项。第一 - 单身模式。我可以使所有方法和变量都是静态的，使构造函数成为私有的，只生成一个实例。第二个解决方案是通过构造函数传递class Foo { private Bar bclass; public int number = 0; Foo() { bclass = new Bar(); } } class Bar { Bar() { // code // Access Foo's number from here } }作为参考。但这并没有解决我在number中访问方法的问题。或者我可以通过构造函数将Foo的整个实例传递给Foo：

Bar

我的程序使用了4个不同的类，它们总是只有一个实例，所有这些类都需要以某种方式与主类或彼此之间进行通信（使用它的变量或方法）。你会推荐我哪种方法？将所有4个班级作为单身人士？

很抱歉，如果标题或文字令人困惑，如果我遗漏了某些内容，我会很乐意回复或编辑我的问题。

Answer 1

好吧，如果你想让你的代码单元可测试，单身不是一个好选择。将其他对象作为私有字段实例化也不是一个好习惯，因为你结合你的代码，我会说更好的选择是在每个类中以特定方法（注入）传递对象，如果你创建接口则更好：

interface IFoo
{
    void SetBar(IBar bar);
}

class Foo : IFoo
{
    private IBar _bar;

    public void SetBar(IBar bar)
    {
        _bar = bar;
    }
}

interface IBar
{
    void SetFoo(IFoo foo);
}

class Bar : IBar
{
    private IFoo _foo;

    public void SetFoo(IFoo foo)
    {
        _foo = foo;
    }
}

class MainClass
{
    private IFoo _foo;
    private IBar _bar;

    public MainClass(IFoo foo, IBar bar)
    {
        _foo = foo;
        _bar = bar;

        _foo.SetBar(bar);
        _bar.SetFoo(foo);
    }
}

class Context // Here you build the structure you want
{
    IFoo _foo;
    IBar _bar;
    MainClass _mainClass;

    public Context()
    {
        _foo = new Foo();
        _bar = new Bar();
        _mainClass = new MainClass(_foo, _bar);
    }
}

这样你的代码就会松散耦合，你可以对它进行单元测试

Answer 2

您可以完全放弃单例，并且更喜欢在构造函数中注入依赖类的引用。例如，如果Bar需要来自Foo的信息，则可以将Foo作为构造函数参数添加到Bar。然后在您的主要课程中，您将新的Foo实例传递给Bar

class Foo {
    //...
}

class Bar {
    private Foo _foo;
    // add Foo as a instance
    Bar(Foo foo) {
        _foo = foo;
        // access foo number here
    }
}

class Program {
    public static void Main(string[] args) {
        var foo = new Foo();
        var bar = new Bar(foo);
    }
}

Answer 3

如果您的类具有声明为internal或public的字段或属性，则其他类可以访问该字段或属性。如果它是internal那么它可以被同一个程序集中的其他类访问（项目。）如果它是public那么它可以被该程序集中的任何类或引用它的其他程序集访问。

// If the class is public then it's visible to other assemblies.
// If the class isn't public then other assemblies can't see public
// members because they can't see the class itself.
public class Foo
{
    // Accessible to classes inside the project.
    internal string SomeField; 

    // Accessible to classes outside the project.
    public string SomeProperty { get; set; }
}

这是你问题的直接答案。在实践中，我们几乎从不在类之外公开字段（变量）。将这些字段视为类的内部状态。为了使其可预测地工作并防止错误，我们不希望其他类改变该类的状态。

这是一个例子。（我对汽车的例子不是很疯狂，但无论如何。）

public class Car
{
    public int SpeedMilesPerHour;
}

问题是任何其他类都可以将SpeedMilesPerHour设置为任何内容。它可以从零到8,000到-10,000,000。这可能不是Car的意图，如果你的车开了3,000英里每小时或20英里每小时，那么你可能有一个错误。

你真的不能指望每一个班级都知道Car应该能够走多快的速度。你会在整个地方都有重复的代码，以确保正确设置速度。

您可以通过Car“隐藏”其速度变量并控制其变化来解决此问题。例如，它可能如下所示：

public class Car
{
    private int _speed;

    public int Speed { get { return _speed; } }

    public void GoFaster()
    {
        if (_speed < 200) _speed++;
    }

    public void SlowDown()
    {
        if (_speed > 0) _speed--;
    }
}

现在_speed是内部的。我们添加了一个属性，以便其他类可以查看的速度。但改变它的唯一方法是致电SpeedUp()或SlowDown()。该类不允许其他类通过意外更改速度或将其设置为无效数字来搞乱其内部状态。

最好的学习方法之一就是试验。

创建控制台应用
更简单，创建一个单元测试项目。同样的事情，但您可以运行一系列测试，而不是您编辑的一个控制台应用程序。
使用[https://dotnetfiddle.net/](.NET小提琴）。当您想为其他人提供一种简单的方法来运行您的代码时，这很方便。

使用reference和singleton访问类之间的变量和方法

3 个答案: