C#::何时使用事件或从事件处理接口(interface)派生的对象集合？

Question

我有一个我认为是简单的“问题”，我已经找到了几个解决方案，但我不确定该走哪条路以及 C# 中的最佳实践。

我有一个主对象(比如一个单例)在应用程序的生命周期内实例化一次。这个“MasterClass”创建了一堆新类型的对象，每次调用 MasterClass.Instance.CreateSlaveObject 时都说“SlaveClass”。

这个 MasterClass 还监视一些其他对象的状态变化，当这种情况发生时，通知它创建的 SlaveClass 对象这个变化。看起来很简单。

由于我来自本地 C++ 世界，所以我首先采用的方式是拥有一个接口(interface)

Interface IChangeEventListener
{
    void ChangeHappened();
}

我从中派生出“SlaveClass”。然后在我的“MasterClass”中我有:

...
IList<IChangeEventListener> slaveList;
...
CreateSlaveObject
{
    ...
    slaveList.Add(slave);
}
...
ChangeHappened()
{
    ...
    foreach(var slave in slaveList)
    {
       slave.ChangeHappened();
    }
}

这行得通。但我一直在想，是否有另一种(更好的)方法可以做到这一点。因此，我对该主题进行了更多研究，并看到了 C# 事件。

因此，我不是在 MasterClass 中维护一个从属集合，而是基本上将 MasterClass 注入(inject)到 SlaveClass 的构造函数中(或通过属性)，并让 SlaveClass 对象将其 ChangeHappened 添加为事件处理程序。这将被说明:

  ...Master...          
  public delegate void ChangeHappenedDelegate(object sender, NewsInfoArgs args);
  public event NewUpdateDelegate ChangeHappenedEvent;
  ....

  public SlaveClass (MasterClass publisher) //inject publisher service
  {
      publisher.ChangeHappenedEvent += ChangeHappened;
  }

但这似乎是 Slave 和 Master 之间不必要的耦合，但我喜欢所提供的内置事件通知机制的优雅。

那么我应该保留我当前的代码，还是转向基于事件的方法(使用发布者注入(inject))？为什么？

或者，如果您能提出一个我可能错过的替代解决方案，我也将不胜感激。

Answer 1

好吧，在我看来，您展示的事件和界面是同一枚硬币的两面(至少在您描述的上下文中是这样)，但它们实际上是这枚硬币的两面。

我对事件的看法是“我需要订阅你的事件，因为我需要你在发生事情时告诉我”。

而接口(interface)方式是“我需要对你调用一个方法来通知你我发生了什么事”。

这听起来可能是一样的，但说话的人不同，在这两种情况下都是您的“大师类”在说话，这就完全不同了。

请注意，如果您的从属类有一个可用的方法，当您的主类发生某些事情时适合调用，您不需要从属类包含代码来连接它，您可以很容易地做到这在您的 CreateSlaveClass 方法中:

SlaveClass sc = new SlaveClass();
ChangeHappenedEvent += sc.ChangeHappened;
return sc;

这基本上会使用事件系统，但让 MasterClass 代码完成所有事件的连接。

SlaveClass 对象是否与单例类一样长寿？如果不是，那么您需要在它们变得陈旧/不再需要时处理这种情况，如上述情况(基本上在您和我的情况下)，您在 MasterClass 中持有对这些对象的引用，因此它们将永远没有资格进行垃圾回收，除非您强行删除这些事件或注销接口(interface)。

---

要处理 SlaveClass 的生命周期不如 MasterClass 长的问题，您将遇到相同的耦合问题，正如您在评论中指出的那样。

“处理”(注意引号)的一种方法可能不是真正直接链接到 SlaveClass 对象上的正确方法，而是创建一个内部将调用此方法的包装器对象。这样做的好处是包装器对象可以在内部使用 Wea​​kReference 对象，这样一旦您的 SlaveClass 对象符合垃圾收集条件，它就可能被收集，然后下次您尝试对其调用正确的方法时，您会注意到这一点，因此您必须进行清理。

例如，像这样(这里我在没有 Visual Studio 智能感知和编译器的情况下打字，请理解这段代码的含义，而不是语法(错误)。)

public class WrapperClass
{
    private WeakReference _Slave;

    public WrapperClass(SlaveClass slave)
    {
        _Slave = new WeakReference(slave);
    }

    public WrapperClass.ChangeHappened()
    {
        Object o = _Slave.Target;
        if (o != null)
            ((SlaveClass)o).ChangeHappened();
        else
            MasterClass.ChangeHappenedEvent -= ChangeHappened;
    }
}

在你的 MasterClass 中，你会做这样的事情:

SlaveClass sc = new SlaveClass();
WrapperClass wc = new WrapperClass(sc);
ChangeHappenedEvent += wc.ChangeHappened;
return sc;

收集 SlaveClass 对象后，下一次从您的 MasterClass 调用事件处理程序(但不会早于此)以通知它们更改，所有不再具有对象的包装器都将被删除。