从通用事件处理程序重定向到动态方法

Question

我正在尝试编写一个类，用于从任意事件触发对方法的调用，但我陷入困境，因为我根本无法找出从发出的 MSIL 代码引用“this”的方法。

这个例子应该描述我正在寻找的内容：

class MyEventTriggeringClass
{ 
    private object _parameter;

    public void Attach(object source, string eventName, object parameter)
    {
        _parameter = parameter;
        var e = source.GetType().GetEvent(eventName);
        if (e == null) return;
        hookupDelegate(source, e);
    }

    private void hookupDelegate(object source, EventInfo e)
    {
        var handlerType = e.EventHandlerType;
        // (omitted some validation here)
        var dynamicMethod = new DynamicMethod("invoker",
                  null,
                  getDelegateParameterTypes(handlerType), // (omitted this method in this exmaple)
                  GetType());
        var ilgen = dynamicMethod.GetILGenerator();
        var toBeInvoked = GetType().GetMethod(
            "invokedMethod", 
            BindingFlags.NonPublic | BindingFlags.Instance);
        ilgen.Emit(OpCodes.Ldarg_0); // <-- here's where I thought I could push 'this' (failed)
        ilgen.Emit(OpCodes.Call, toBeInvoked);
        ilgen.Emit(OpCodes.Ret);
        var sink = dynamicMethod.CreateDelegate(handlerType);
        e.AddEventHandler(source, sink);
    }

    private void invokedMethod()
    {
        Console.WriteLine("Value of _parameter = " + _parameter ?? "(null)"); 
        // output is always "(null)"
    }
}

这是我设想如何使用该类的例子：（

var handleEvent = new MyEventTriggeringClass();
handleEvent.Attach(someObject, "SomeEvent", someValueToBePassedArround);

请注意，上面的例子毫无意义。我只是试图描述我正在寻找的内容。我的最终目标是为了能够在任意事件触发时触发对任意方法的调用，我将在 WPF 项目中使用它，我尝试使用 100% MVVM，但我偶然发现了一个[看似]经典的方法。断点。）

无论如何，代码“有效”，只要它在任意事件触发时成功调用“invokedMethod”，但“this”似乎是一个空对象（_parameter 始终为 null）。我做了一些研究，但根本找不到任何好的例子，其中“this”被正确地传递给从这样的动态方法中调用的方法。

我发现的最接近的例子是这篇文章，但在该示例中'this ' 可以强制使用动态方法，因为它是从代码调用的，而不是任意事件处理程序。

任何建议或提示将不胜感激。

Answer 1

由于 .Net 中委托差异的工作方式，您可以在不使用 codegen 的情况下用 C# 编写代码：

private void InvokedMethod(object sender, EventArgs e)
{
    // whatever
}

private MethodInfo _invokedMethodInfo =
    typeof(MyEventTriggeringClass).GetMethod(
        "InvokedMethod", BindingFlags.Instance | BindingFlags.NonPublic);

private void hookupDelegate(object source, EventInfo e)
{
    Delegate invokedMethodDelegate = 
        Delegate.CreateDelegate(e.EventHandlerType, this, _invokedMethodInfo);
    e.AddEventHandler(source, invokedMethodDelegate);
}

为了解释一下，假设您有一些遵循标准事件模式的事件，即 return类型是 void，第一个参数是 object，第二个参数是 EventArgs 或从 EventArgs 派生的某种类型。如果您已按上述方式定义了该内容和 InvokeMethod，则可以编写 someObject.theEvent += InvokedMethod。这是允许的，因为它是安全的：您知道第二个参数是可以充当 EventArgs 的某种类型。

上面的代码基本相同，除了在将事件作为 EventInfo 给出时使用反射。只需创建一个引用我们的方法的正确类型的委托并订阅该事件即可。

Answer 2

如果您确定要采用 codegen 方式，可能是因为您也想支持非标准事件，您可以这样做：

每当您想要附加到事件时，创建一个具有以下方法的类：匹配事件的委托类型。该类型还将有一个字段来保存传入的参数。 （更接近您的设计的是一个包含对 MyEventTriggeringClass 的 this 实例的引用的字段，但我认为这种方式更有意义。）此字段设置在构造函数。

该方法将调用 invokedMethod，并将 parameter 作为参数传递。 （这意味着 invokedMethod 必须是公共的，并且可以设为静态，如果您没有其他理由保持非静态。）

当我们创建完类后，创建一个实例它，创建该方法的委托并将其附加到事件。

public class MyEventTriggeringClass
{
    private static readonly ConstructorInfo ObjectCtor =
        typeof(object).GetConstructor(Type.EmptyTypes);

    private static readonly MethodInfo ToBeInvoked =
        typeof(MyEventTriggeringClass)
            .GetMethod("InvokedMethod",
                       BindingFlags.Public | BindingFlags.Static);

    private readonly ModuleBuilder m_module;

    public MyEventTriggeringClass()
    {
        var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
            new AssemblyName("dynamicAssembly"),
            AssemblyBuilderAccess.RunAndCollect);

        m_module = assembly.DefineDynamicModule("dynamicModule");
    }

    public void Attach(object source, string @event, object parameter)
    {
        var e = source.GetType().GetEvent(@event);
        if (e == null)
            return;
        var handlerType = e.EventHandlerType;

        var dynamicType = m_module.DefineType("DynamicType" + Guid.NewGuid());

        var thisField = dynamicType.DefineField(
            "parameter", typeof(object),
            FieldAttributes.Private | FieldAttributes.InitOnly);

        var ctor = dynamicType.DefineConstructor(
            MethodAttributes.Public, CallingConventions.HasThis,
            new[] { typeof(object) });

        var ctorIL = ctor.GetILGenerator();
        ctorIL.Emit(OpCodes.Ldarg_0);
        ctorIL.Emit(OpCodes.Call, ObjectCtor);
        ctorIL.Emit(OpCodes.Ldarg_0);
        ctorIL.Emit(OpCodes.Ldarg_1);
        ctorIL.Emit(OpCodes.Stfld, thisField);
        ctorIL.Emit(OpCodes.Ret);

        var dynamicMethod = dynamicType.DefineMethod(
            "Invoke", MethodAttributes.Public, typeof(void),
            GetDelegateParameterTypes(handlerType));

        var methodIL = dynamicMethod.GetILGenerator();
        methodIL.Emit(OpCodes.Ldarg_0);
        methodIL.Emit(OpCodes.Ldfld, thisField);
        methodIL.Emit(OpCodes.Call, ToBeInvoked);
        methodIL.Emit(OpCodes.Ret);

        var constructedType = dynamicType.CreateType();

        var constructedMethod = constructedType.GetMethod("Invoke");

        var instance = Activator.CreateInstance(
            constructedType, new[] { parameter });

        var sink = Delegate.CreateDelegate(
            handlerType, instance, constructedMethod);

        e.AddEventHandler(source, sink);
    }

    private static Type[] GetDelegateParameterTypes(Type handlerType)
    {
        return handlerType.GetMethod("Invoke")
                          .GetParameters()
                          .Select(p => p.ParameterType)
                          .ToArray();
    }

    public static void InvokedMethod(object parameter)
    {
        Console.WriteLine("Value of parameter = " + parameter ?? "(null)");
    }
}

不过，这仍然无法考虑所有可能的事件。这是因为事件的委托可以有返回类型。这意味着为生成的方法提供一个返回类型并从中返回一些值（可能是 default(T)）。

（至少）有一种可能的优化：不要每次都创建新类型，而是缓存它们。当您尝试附加到与前一个事件具有相同签名的事件时，请使用其类。

Answer 3

我将继续在这里回答我自己的问题。一旦我意识到真正的问题是什么，解决方案就非常简单：指定事件处理程序的实例/目标。这是通过向 MethodInfo.CreateDelegate() 添加参数来完成的。

如果您感兴趣，这里有一个简单的示例，您可以将其剪切并粘贴到控制台应用程序中并尝试一下：

class Program
{
    static void Main(string[] args)
    {
        var test = new MyEventTriggeringClass();
        var eventSource = new EventSource();
        test.Attach(eventSource, "SomeEvent", "Hello World!");
        eventSource.RaiseSomeEvent();
        Console.ReadLine();
    }
}

class MyEventTriggeringClass
{
    private object _parameter;

    public void Attach(object eventSource, string eventName, object parameter)
    {
        _parameter = parameter;
        var sink = new DynamicMethod(
            "sink",
            null,
            new[] { typeof(object), typeof(object), typeof(EventArgs) },
            typeof(Program).Module);

        var eventInfo = typeof(EventSource).GetEvent("SomeEvent");

        var ilGenerator = sink.GetILGenerator();
        var targetMethod = GetType().GetMethod("TargetMethod", BindingFlags.Instance | BindingFlags.Public, null, new Type[0], null);
        ilGenerator.Emit(OpCodes.Ldarg_0); // <-- loads 'this' (when sink is not static)
        ilGenerator.Emit(OpCodes.Call, targetMethod);
        ilGenerator.Emit(OpCodes.Ret);

        // SOLUTION: pass 'this' as the delegate target...
        var handler = (EventHandler)sink.CreateDelegate(eventInfo.EventHandlerType, this);
        eventInfo.AddEventHandler(eventSource, handler);
    }

    public void TargetMethod()
    {
        Console.WriteLine("Value of _parameter = " + _parameter);
    }
}

class EventSource
{
    public event EventHandler SomeEvent;

    public void RaiseSomeEvent()
    {
        if (SomeEvent != null)
            SomeEvent(this, new EventArgs());
    }
}

所以，感谢您的评论和帮助。希望有人能学到一些东西。我知道我做到了。

干杯

Answer 4

这是我自己的版本/满足我自己的需要：

    /// <summary>
    /// Corresponds to 
    ///     control.Click += new EventHandler(method);
    /// Only done dynamically, and event arguments are omitted.
    /// </summary>
    /// <param name="objWithEvent">Where event resides</param>
    /// <param name="objWhereToRoute">To which object to perform execution to</param>
    /// <param name="methodName">Method name which to call. 
    ///  methodName must not take any parameter in and must not return any parameter. (.net 4.6 is strictly checking this)</param>
    private static void ConnectClickEvent( object objWithEvent, object objWhereToRoute, string methodName )
    {
        EventInfo eventInfo = null;

        foreach (var eventName in new String[] { "Click" /*WinForms notation*/, "ItemClick" /*DevExpress notation*/ })
        {
            eventInfo = objWithEvent.GetType().GetEvent(eventName);
            if( eventInfo != null )
                break;
        }

        Type objWhereToRouteObjType = objWhereToRoute.GetType();
        var method = eventInfo.EventHandlerType.GetMethod("Invoke");
        List<Type> types = method.GetParameters().Select(param => param.ParameterType).ToList();
        types.Insert(0, objWhereToRouteObjType);

        var methodInfo = objWhereToRouteObjType.GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[0], null);
        if( methodInfo.ReturnType != typeof(void) )
            throw new Exception("Internal error: methodName must not take any parameter in and must not return any parameter");

        var dynamicMethod = new DynamicMethod(eventInfo.EventHandlerType.Name, null, types.ToArray(), objWhereToRouteObjType);

        ILGenerator ilGenerator = dynamicMethod.GetILGenerator(256);
        ilGenerator.Emit(OpCodes.Ldarg_0);
        ilGenerator.EmitCall(OpCodes.Call, methodInfo, null);
        ilGenerator.Emit(OpCodes.Ret);

        var methodDelegate = dynamicMethod.CreateDelegate(eventInfo.EventHandlerType, objWhereToRoute);
        eventInfo.AddEventHandler(objWithEvent, methodDelegate);
    } //ConnectClickEvent