Question

我正在开发某种EventSourcing架构，并在我的应用中有两个主要概念 - events和handlers。

事件示例：

class NewRecordCreated: EventMessage {...}

有些处理程序看起来像：

class WriteDBHandler: IEventHandler<NewRecordCreated>, IEventHandler<RecordUpdated> { 
    public void Handle(NewRecordCreated eventMessage) {...}
    public void Handle(RecordUpdated eventMessage) {...} 
}

我还有队列协议的自定义实现，它将事件分派给适当的处理程序。因此，基本上在应用程序启动时，我会解析程序集并根据类型在事件和处理程序之间创建映射。

因此，当我实际上将事件分派给处理程序时，我基于事件类型获取处理程序类型的链 - 类似于var handlerChain = [typeof(WriteDbHandler), typeof(LogHandler), typeof(ReadModelUpdateHandler)]，并且对于每个处理程序，我需要调用它的实例，然后将其转换为正确的接口（{ {1}}）而不是调用IEventHandler<>方法。

但我无法转换为通用接口，因为它不可能。我考虑实现非泛型版本的接口的选项，但是每次添加额外的方法实现对我来说似乎很不愉快，特别是如果没有任何真正的原因。

我考虑动态调用或反射，但这两种变体似乎都存在性能问题。也许你可以给我一些合适的选择？

Answer 1

使用反射

您可以使用反射来获取对需要调用的方法的引用，而不是尝试强制转换为IEventHandler<>。下面的代码就是一个很好的例子。为简洁起见，它简化了“队列协议”，但它应该充分说明您需要做的反思。

class MainClass
{
    public static void Main(string [] args)
    {
        var a = Assembly.GetExecutingAssembly();
        Dictionary<Type, List<Type>> handlerTypesByMessageType = new Dictionary<Type, List<Type>>();

        // find all types in the assembly that implement IEventHandler<T>
        // for some value(s) of T
        foreach (var t in a.GetTypes())
        {
            foreach (var iface in t.GetInterfaces())
            {
                if (iface.GetGenericTypeDefinition() == typeof(IEventHandler<>))
                {
                    var messageType = iface.GetGenericArguments()[0];
                    if (!handlerTypesByMessageType.ContainsKey(messageType))
                        handlerTypesByMessageType[messageType] = new List<Type>();
                    handlerTypesByMessageType[messageType].Add(t);
                }
            }
        }

        // get list of events
        var messages = new List<EventMessage> {
            new NewRecordCreated("one"),
            new RecordUpdated("two"),
            new RecordUpdated("three"),
            new NewRecordCreated("four"),
            new RecordUpdated("five"),
        };

        // process all events
        foreach (var msg in messages)
        {
            var messageType = msg.GetType();
            if (!handlerTypesByMessageType.ContainsKey(messageType))
            {
                throw new NotImplementedException("No handlers for that type");
            }

            if (handlerTypesByMessageType[messageType].Count < 1)
            {
                throw new NotImplementedException("No handlers for that type");
            }

            // look up the handlers for the message type
            foreach (var handlerType in handlerTypesByMessageType[messageType])
            {
                var handler = Activator.CreateInstance(handlerType);
                // look up desired method by name and parameter type
                var handlerMethod = handlerType.GetMethod("Handle", new Type[] { messageType });
                handlerMethod.Invoke(handler, new object[]{msg});
            }
        }
    }
}

我编译了这个并在我的机器上运行它并得到了我认为正确的结果。

使用运行时代码生成

如果反射速度不够快，您可以为每种输入消息类型即时编译代码并执行该代码。 System.Reflection.Emit命名空间具有执行此操作的功能。您可以定义一个动态方法（不要与dynamic关键字混淆，这是其他的东西），如果IL操作码将按顺序运行列表中的每个处理程序，则发出一个序列。

public static Dictionary<Type, Action<EventMessage>> GenerateHandlerDelegatesFromTypeLists(Dictionary<Type, List<Type>> handlerTypesByMessageType)
{
    var handlersByMessageType = new Dictionary<Type, Action<EventMessage>>();
    foreach (var messageType in handlerTypesByMessageType.Keys)
    {
        var handlerTypeList = handlerTypesByMessageType[messageType];

        if (handlerTypeList.Count < 1)
            throw new NotImplementedException("No handlers for that type");

        var method =
            new DynamicMethod(
                "handler_" + messageType.Name,
                null,
                new [] { typeof(EventMessage) });
        var gen = method.GetILGenerator();
        foreach (var handlerType in handlerTypeList)
        {
            var handlerCtor = handlerType.GetConstructor(new Type[0]);
            var handlerMethod =
                handlerType.GetMethod("Handle", new Type[] { messageType });

            // create an object of the handler type
            gen.Emit(OpCodes.Newobj, handlerCtor);
            // load the EventMessage passed as an argument
            gen.Emit(OpCodes.Ldarg_0);
            // call the handler object's Handle method
            gen.Emit(OpCodes.Callvirt, handlerMethod);
        }

        gen.Emit(OpCodes.Ret);

        var del = (Action<EventMessage>)method.CreateDelegate(
            typeof(Action<EventMessage>));

        handlersByMessageType[messageType] = del;
    }
}

然后，您只需使用handlerMethod.Invoke(handler, new object[]{msg})调用代理，而不是使用handlersByMessageType[messageType](msg)调用处理程序。

完整代码列表here。

实际的代码生成是在GenerateHandlerDelegatesFromTypeLists方法中完成的。它实例化一个新的DynamicMethod，获取其关联的ILGenerator，然后依次为每个处理程序发出操作码。对于每个处理程序类型，它将实例化该处理程序类型的新对象，将事件消息加载到堆栈，然后在处理程序对象上为该消息类型执行Handle方法。这当然假设处理程序类型都具有零参数构造函数。但是，如果需要将参数传递给构造函数，则必须对其进行相当大的修改。

还有其他方法可以加快速度。如果您放松了为每条消息创建新处理程序对象的要求，那么您可以在生成代码时创建对象并加载它们。在这种情况下，请将gen.Emit(OpCodes.Newobj, handlerCtor)替换为gen.Emit(OpCodes.Ldobj, handlerObjectsByType[handlerType])。这给你带来两个好处： 1.你要避免对每条消息进行分配 2.您可以在填充handlerObjectsByType字典时以任何方式实例化对象。您甚至可以使用带参数或工厂方法的构造函数。

在运行时调用通用接口方法的有效方法

1 个答案:

使用反射

使用运行时代码生成