5

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

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

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 时总是首选事件？
  • 每种解决方案的优缺点是什么？
4

1 回答 1

3

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

  • 事件- 根据 DI 书籍的首选方式，您已经这样做了。对我来说看起来不错
  • 属性注入——与构造函数注入相反，属性注入意味着注入的资源是可选的。

在具有属性的第二个实现中，有一个构造函数：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.DoStuffBefore()调用Before，或者如果需要则引发异常

根据你的问题：

  • 哪个被认为是最好的设计？有什么指导方针？利弊——恕我直言，两者都可以。事件更笼统。属性更容易实现和处理
  • 返回 void 时，事件总是首选？- 我同意
于 2012-12-17T18:44:31.120 回答