c# - 如果使用 DI + MEF，在容器中的类之间传递事件的好方法是什么？

Question

我有一个包含数百个类的 MEF 容器。在不同类之间传递消息的好方法是什么？

我更喜欢一种适用于任何依赖注入(inject) (DI) 容器的解决方案，包括 Unity、CaSTLe Windsor 等。

Answer 1

注意:这是一个“分享您的知识，问答式”条目。

介绍事件发布者

此事件发布者允许 MEF 容器中的任何类向 MEF 容器中的任何其他类发送消息。

这段代码已经经过多年的实践证明，并被证明在使用 WPF/MVVM 时特别有用。

这是一个一对多的订阅，所以一旦消息被发送出去，它就会被任何正在观察该自定义类型消息的监听器接收到。

此示例适用于 MEF，但它也适用于任何其他依赖注入(inject) (DI) 容器，例如 Unity、CaSTLe Windsor 等。如果您转换 EventPublisher对于单例，您可以将其与普通 C# 一起使用(即不使用 DI 容器)。如果您想让我发布代码，请告诉我。

这段代码并不是什么新鲜事:在开源社区中还有数百种事件发布者的其他实现，例如在 MVVM 光中。但是，此示例使用的代码量如此之少，以至于可以通过在调试器中单步执行来查看它在后台的工作方式。

C# 用法

将样板代码添加到您的项目中(见下文)。

创建您的自定义事件类型。这可以是一个类、一个结构，甚至是一个枚举，例如:

public enum NavigationType
{
    Unknown = 0,
    MyOption1,
    MyOption2
}

... 然后，我可以导入 eventPublisher进入任何类(class)，像这样:

[ImportingConstructor]
public BrokerOrderSearchResultViewModel(
    IEventPublisher<NavigationType> eventPublisher,
    )
{
    _eventPublisher = eventPublisher;
    ...

... 在构造函数中，我可以订阅 NavigationType 类型的事件:

_eventPublisher.GetEvent<NavigationType>().Subscribe(o => 
{
    Console.Write(o);
});

...以及其他任何地方，我可以推出事件，这些事件将在订阅中接收:

_eventPublisher.Publish(NavigationType.MyOption1);

C# 锅炉板代码

添加Reactive Extensions (RX) NuGet package到您的项目。

创建这个界面:

public interface IEventPublisher
{
    IObservable<TEvent> GetEvent<TEvent>();
    void Publish<TEvent>(TEvent sampleEvent);
}

public interface IEventPublisher<in T>
{
    IObservable<TEvent> GetEvent<TEvent>() where TEvent : T;
    void Publish<TEvent>(TEvent sampleEvent) where TEvent : T;
}

...使用此实现:

// NOTE: This class must be a singleton (there should only ever
// be one copy; this happens automatically in any dependency injection
// container). This class is the central dictionary that routes events
// of any incoming type, to all listeners for that same type.
[Export(typeof (IEventPublisher))]
public class EventPublisher : IEventPublisher
{
    private readonly ConcurrentDictionary<Type, object> _subjects;


    public EventPublisher()
    {
        _subjects = new ConcurrentDictionary<Type, object>();
    }

    public IObservable<TEvent> GetEvent<TEvent>()
    {
        return (ISubject<TEvent>)_subjects.GetOrAdd(typeof(TEvent), t => new Subject<TEvent>());
    }

    public void Publish<TEvent>(TEvent sampleEvent)
    {
        object subject;
        if (_subjects.TryGetValue(typeof (TEvent), out subject))
        {
            ((ISubject<TEvent>)subject).OnNext(sampleEvent);
        }
        // Could add a lock here to make it thread safe, but in practice,
        // the Dependency Injection container sets everything up once on
        // startup and it doesn't change from that point on, so it just
        // works.
    }
}

// NOTE: There can be many copies of this class, one for
// each type of message. This happens automatically in any
// dependency injection container because its a <T> class. 
[Export(typeof (IEventPublisher<>))]
public class EventPublisher<T> : IEventPublisher<T>
{
    private readonly IEventPublisher _eventPublisher;

    [ImportingConstructor]
    public EventPublisher(IEventPublisher eventPublisher)
    {
        _eventPublisher = eventPublisher;
    }

    public IObservable<TEvent> GetEvent<TEvent>() where TEvent : T
    {
        return _eventPublisher.GetEvent<TEvent>();
    }

    public void Publish<TEvent>(TEvent sampleEvent) where TEvent : T
    {
        _eventPublisher.Publish(sampleEvent);
    }
}

讨论

这段代码展示了从任何类向任何其他类发送事件是多么简单。

如图所示，您需要创建一个新的自定义类型才能发送消息。类型可以是枚举、结构或类。如果类型是类或结构，它可以包含任意数量的属性。如果使用特定的自定义类型发送消息，则所有收听该类型消息的订阅者都将收到它。您可以创建许多自定义类型，一个用于您需要与之通信的每种类型的事件。

在幕后，所有代码所做的就是保存自定义类型的字典。在发送时，它会在字典中查找合适的订阅者，然后使用 Reactive Extensions (RX) 发送消息。然后所有收听该类型的订阅者都会收到该消息。

有时，如果有太多的事件到处飞来飞去，就很难看出哪些类正在与哪些其他类进行通信。在这种情况下，很简单:您可以使用“在文件中查找”来查找包含字符串 IEventPublisher<NavigationType> 的所有类。 ，它最终列出了所有发送或收听我们自定义类型事件的类 NavigationType .

注意:这段代码不是 Elixir 。过多地依赖事件是一种不好的代码味道，因为类层次结构应该以这样的方式组成，即类不应该依赖于它们的父类。有关更多信息，请研究 SOLID 原则，尤其是 LSP。然而，有时使用事件是不可避免的，因为我们别无选择，只能跨越类层次结构。

future 的改进

目前，这个事件发布者没有实现 IDisposable。应该的。