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

2023年9月18日 163次阅读

我正在研究某种EventSourcing架构,并在我的应用程序中有两个主要概念 – 事件和处理程序.

事件示例：

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)]以及我需要调用的每个处理程序它的实例,然后将其转换为适当的接口(IEventHandler<>),然后调用Handle方法.

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

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

最佳答案 用反射

您可以使用反射来获取对需要调用的方法的引用,而不是尝试强制转换为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命名空间具有执行此操作的功能.
您可以定义一个动态方法(不要与动态关键字混淆,这是其他的东西),如果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的处理器(处理器,新的对象[] {}味精),你只需要调用该委托像任何其他与handlersByMessageType [为messageType(MSG).

完整代码列表here.

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

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

点赞