依赖注入与事件以及通过事件解决循环依赖关系

Question

我一直致力于重构应用程序，以通过依赖注入和所有其他好东西使其更易于管理。这样做时，我不止一次遇到循环依赖。

所以这里是一个循环依赖的典型例子：

interface IA
{
    int Data { get; }
}
interface IBefore
{
    void DoStuffBefore();
}
class A: IA
{
    public int Data { get; private set; }
    IBefore before;
    public A(IBefore before)
    {
        this.before = before;
    }
    public void Increment()
    {
        before.DoStuffBefore();
        Data++;
    }
}
class B: IBefore
{
    IA a;
    public B(IA a)
    {
        this.a = a;
    }
    public void WriteADataToConsole()
    {
        Console.Write(a.Data);
    }
    public void DoStuffBefore() //From IBefore
    {
        WriteADataToConsole();
    }
}

我不能创建这两个类，因为它们需要彼此。现在，在这种情况下要做的标准（？）事情是将 A 的数据与 A 分开：

public interface IA
{
    int Data { get; set; }
}
public interface IBefore
{
    void DoStuffBefore();
}
class AData : IA
{
    public int Data { get; set; }
}
class A
{
    public IA Data { get; private set; }
    IBefore before;
    public A(IA data, IBefore before)
    {
        this.Data = data;
        this.before = before;
    }
    public void Increment()
    {
        before.DoStuffBefore();
        Data.Data++;
    }
}
class B : IBefore
{
    IA a;
    public B(IA a)
    {
        this.a = a;
    }
    public void WriteADataToConsole()
    {
        Console.Write(a.Data);
    }
    public void DoStuffBefore() //From IBefore
    {
        WriteADataToConsole();
    }
}

以上解决了循环依赖，因为我现在可以先创建 AData，然后将其注入 B 并将 B 注入 A。但我也可以将事件 i IA 放入 B 可以听的：

public interface IA
{
    int Data { get; }
    event Action BeforeEvent;
}

class A: IA
{
    public int Data { get; private set; }
    public event Action BeforeEvent;
    public void Increment()
    {
        BeforeEvent();
        Data++;
    }
}

class B
{
    IA a;
    public B(IA a)
    {
        this.a = a;
        a.BeforeEvent += new Action(WriteADataToConsole);
    }
    void WriteADataToConsole() //Event listener
    {
        Console.Write(a.Data);
    }
}

这是我偶然发现的，因为我试图将事件方法转换为依赖注入，并意识到这样做我得到了一个循环依赖。

困扰我大脑的一些问题是：

• 这两种解决方案都解决了循环依赖问题（对吗？），据我所知，它们都可以将 A 扩展到同等程度，但哪种设计会被认为是最佳设计？
• 对于何时使用事件以及何时使用 DI 来解决循环依赖以及一般情况，有哪些指导方针？
• 如果 A 需要 B 的返回值，显然事件是不好的。这是否意味着当返回 void 时总是首选事件？
• 每种解决方案的优缺点是什么？

Answer 1

好问题！在 95% 的情况下，您必须要么将这两个实体合并在一起，要么以其他方式打破依赖关系，但是……如果你不能出于某种原因将它们合并到一个实体中怎么办（使用 UI有时可能会如此棘手）？有一本书是关于 "Dependency Injection in .NET" by Mark Seemann 的，其中描述了两种打破循环依赖的方法：

• Events — 根据 DI 书籍的首选方式，您已经这样做了。 我觉得不错
• Property Injection — 与 Constructor Injection 相比，Property Injection 意味着注入的资源是可选的。

在您的第二个带有属性的实现中，有一个构造函数：public A(IA data, IBefore before) 。在依赖注入方面，IA data 和 IBefore before 都是必需的 - 这是破解 cicle 的最佳点！这是一个带有可选IBefore的实现：

class A
{
    public IA Data { get; private set; }
    public IBefore Before { get; set; }

    public A(IA data)
    {
        this.Data = data;
    }
    public void Increment()
    {
        // here should be design decision: if Before is optional…
        if(Before == null)
        {
            Before.DoStuffBefore();
        }    

        // …or required
        if(Before == null)
        {
            throw new Exception("'Before' is required");
        }

        Data.Data++;
    }
}

这取决于您，如果Before 是可选的，则跳过Before.DoStuffBefore() 调用，或者如果需要则引发异常

根据您的问题：

• 哪个被认为是最好的设计？有什么指导方针？优点和缺点 - 恕我直言，两者都可以。事件更笼统。属性更容易实现和处理
• 当返回 void 时，事件总是更可取的？——对我来说是的