Question

我有3个这样的课程：

class MainClass
{
   public Status status1;
   public Control control1;
}

class Status
{
   MainClass mainClass;
   public void testStatus()
   {
      mainClass.control1.testControl();
   }
}

class Control
{
   public void testControl()
   {
   }
}

我不知道“mainClass.control1.testControl（）”行是否是正确的工作或OOP世界中的脏工作。如果不是一个好的情况，这种情况的解决方案是什么。

Answer 1

我认为它没有意义。 MainClass引用了Control / Status，因此它似乎是最合乎逻辑的控制器对象。但是，你没有明确指出每个类如何与彼此相关，所以没有太多可以去那里......

如果Status上的Control depedant ，那么应该明确地传递控制权。

public class Status
{
    private Control control;

    public Status(Control control)
    {
        this.control = control;
    }

    public void testStatus()
    {
        this.control.TestControl();
    }
}

另外，假设MainClass中的Status引用应该是父，那么您也需要将其传递给它。但是，如果它的唯一目的是调用TestControl，则根本不需要它。

Answer 2

这实际上取决于您希望限制对兄弟控件的访问权限。

也许有一个方法可以获取你想要测试的控件的索引？

bool TestControl(int index)
{
    return controls[0].TestControl();
}

Answer 3

问题中的示例代码并没有真正遵循“高内聚和低耦合”的OO原则。尝试以Status不需要Control的知识的方式重新思考解决方案。考虑一下设计模式（比如'Observer'模式）。

Answer 4

是的，我发现了一些问题，

存在循环依赖性b / w Main和Status。
责任处理不当

您的Main类与Status和Control保持关联。从代码我的理解是Status是一个类来检查任何给予Control，但没有与任何特定控件相关联，所以那里有一个弱关联..

在这种情况下，我发现将控制权传递给状态会更好.. 状态testStatus方法获取要测试的Control的参数，并检查返回状态。以下是代码

<强>＃1

class MainClass
{
    public Status status1;
    public Control control1;
}

class Status
{        
    public void testStatus(Control control)
    {
        control.testControl();
    }
}

class Control
{
    public void testControl()
    {
    }
}

如果需要更紧密的耦合，可以将Status作为属性添加到Control。这样Main只与Control相关联，Control会在需要时返回Status。责任得到妥善整理。

<强>＃2

class MainClass
{
    Control control1;

    public void TestMethod()
    {
        control1 = new Control();
        Status control1Status = control1.GetStatus();
    }

}

class Status
{
    public Status(Control control)
    {
        //do status Initiation
        IsValid = true //or false
    }

    public bool IsValid
    {
        get;
        private set;
    }
}

class Control
{
    public Status GetStatus()
    {
        return new Status(this);
    }
}

＃2 更好

Answer 5

这里没有提供太多信息，但您怀疑它不是很好的代码。耦合的原因。你使你的课程彼此严重依赖，并且在他们之间进行交叉引用，这很糟糕。

我建议使用接口来解决这个问题，其中包括：

public interface IStatus
{
    void TestStatus();
}

public interface Control
{
    void testControl();
}

public interface IMainClass {}

internal class MainClass : IMainClass
{
    public IStatus status1;
    public IControl control1;
}

internal class Status : IStatus
{
    public IMainClass mainClass;

    public void testStatus()
    {
        mainClass.control1.testControl();
    }
}

internal class Control : IControl
{
    public void testControl()
    {
    }
}

允许两个子类实例访问彼此的方法

5 个答案: