域事件模式单点到队列事件

当您必须处理多种类型的事件时，它可能会变得有点复杂。正如您可能已经注意到的那样，您不能只使用派生泛型类型，并期望像使用基泛型一样使用它。NET方差不支持你想要使用它的地方。

你需要一个"base"类型，这将是您作为"事件"接受的最小(或最窄)类型。我通常使用像public interface IEvent{}这样的标记接口。当然，你可以从Object推导;但我发现有标记接口很有用，它可以让你订阅或发布一个"事件"显式(这意味着你不能发布任何类型的对象，只能发布"事件")。

从处理多类型方面来看，您需要编写一个类来执行窄化(接受派生类型并"发布")。同一对象转换为派生类型)。即使这样，你也需要通过一个合适的实例来路由你的事件。方差限制)。然后，当然，您可以对同一事件类型拥有多个订阅者;因此，您需要一些东西将事件路由到多个订阅者。这通常被称为多路复用，这将是IEventPublisher的专业化。每个事件类型需要一个多路复用器——这将使用较窄的。对于给定事件使用哪个多路复用器取决于类型，因此多路复用器集合将由字典管理，以便您可以按类型查找它们。然后，要按类型向多个订阅者发布事件，只需查找多路复用器并调用其IEventPublisher.Publish方法。管理多路复用器的是一种IEventPublisher，通常称为Dispatcher(有些人可能称之为路由器)。

public class NarrowingSubscriber<TBase, TDerived> : IEventSubscriber<TBase>
    where TDerived : TBase
    where TBase : IEvent
{
    private IEventSubscriber<TDerived> inner;
    public NarrowingSubscriber(IEventSubscriber<TDerived> inner)
    {
        if (inner == null) throw new ArgumentNullException("inner");
        this.inner = inner;
    }
    public void AttachSubscriber(IEventSubscriber<TDerived> subscriber)
    {
        inner = subscriber;
    }
    public void Handle(TBase data)
    {
        inner.Handle((TDerived)data);
    }
}
public class Multiplexor<T> : IEventSubscriber<T> where T : IEvent
{
    private readonly List<IEventSubscriber<T>> subscribers =
        new List<IEventSubscriber<T>>();
    public void AttachSubscriber(IEventSubscriber<T> subscriber)
    {
        subscribers.Add(subscriber);
    }
    public void RemoveSubscriber(IEventSubscriber<T> subscriber)
    {
        subscribers.Remove(subscriber);
    }
    public void Handle(T data)
    {
        subscribers.ForEach(x => x.Handle(data));
    }
}
public class Dispatcher<TBase> : IEventPublisher<TBase> where TBase : IEvent
{
    private readonly Dictionary<Type, Multiplexor<TBase>> subscriptions =
        new Dictionary<Type, Multiplexor<TBase>>();
    public void Publish(TBase data)
    {
        Multiplexor<TBase> multiplexor;
        if (subscriptions.TryGetValue(data.GetType(), out multiplexor))
        {
            multiplexor.Handle(data);
        }
    }
    public void Subscribe<TEvent>(IEventSubscriber<TEvent> handler)
        where TEvent : TBase
    {
        Multiplexor<TBase> multiplexor;
        if (!subscriptions.TryGetValue(typeof(TEvent), out multiplexor))
        {
            multiplexor = new Multiplexor<TBase>();
            subscriptions.Add(typeof(TEvent), multiplexor);
        }
        multiplexor.AttachSubscriber(new NarrowingSubscriber<TBase, TEvent>(handler));
    }
}

你基本上发布了4次。一次发送给调度器，一次发送给多路复用器，一次发送给窄通道，一次发送给非基础设施订阅者。如果您有两个订阅者(EventOneEventSubscriber和EventTwoEventSubscriber)订阅两种类型的事件(EventOne和EventTwo)，那么您可以创建一个调度程序并像这样发布事件:

var d = new Dispatcher<IEvent>();
var eventTwoSubscriber = new EventTwoEventSubscriber();
d.Subscribe(eventTwoSubscriber);
var eventOneSubscriber = new EventOneEventSubscriber();
d.Subscribe(eventOneSubscriber);
d.Publish(new EventOne());
d.Publish(new EventTwo());

当然，事件将派生自IEvent:

public class EventOne : IEvent
{
}
public class EventTwo : IEvent
{
}

这个特殊的限制没有考虑多次调度事件。例如，我可以为EventOne设置一个订阅者，为IEvent设置一个订阅者。如果通过调度程序发布EventOne对象，则此实现仅将其发布到EventOne订阅者—它不会发布到IEvent订阅者。我将把它留给读者作为练习:)

如果您希望做的是自动连接订阅者而不必构造它们(我认为这样做没有多大价值，考虑一个组合根)，那么您可以向Dispatcher(或其他地方，如果需要)添加一个相当简单的方法来订阅所有兼容的订阅者:

public void InitializeSubscribers()
{
    foreach (object subscriber in
        from assembly in AppDomain.CurrentDomain.GetAssemblies()
        from type in assembly.GetTypes()
        where !type.IsAbstract && type.IsClass && !type.ContainsGenericParameters &&
              type.GetInterfaces().Any(t => t.IsGenericType &&
                                            t.GetGenericTypeDefinition() == typeof (IEventSubscriber<>))
        select type.GetConstructor(new Type[0])
        into constructorInfo
        where constructorInfo != null
        select constructorInfo.Invoke(new object[0]))
    {
        Subscribe((dynamic) subscriber);
    }
}

，你可以这样使用:

var d = new Dispatcher<IEvent>();
d.InitializeSubscribers();

…如果需要，可以使用容器来解析Dispatcher<T>对象