c# - 使用反射动态绑定(bind)到 C# 事件

Question

我有一个 WPF 控件，文档很差。

在代码隐藏中，我想反射(reflect)控件使用 GetType().GetEVents() 触发的事件，并为每个事件添加一个处理程序，它只打印出事件的名称.

这将使我能够看到与控件的交互实际上在做什么。

到目前为止我有:

foreach (var e in GetType().GetEvents())
{
    var name = e.Name;
    var handler = new Action<object,object>( (o1,o2) =>Console.WriteLine(name));

    try
    {
        e.AddEventHandler(
                     this,
                     Delegate.CreateDelegate(
                               e.EventHandlerType,
                               handler.Target, 
                               handler.Method
                               ));
    }
    catch (Exception ex)
    {
        Console.WriteLine( "Failed to bind to event {0}", e.Name);
    }
}

这似乎在事件签名为 (object,EventArgs) 时有效，但在某些其他事件上无法绑定(bind)。

有没有办法在不知道事件签名的情况下做到这一点？

Answer 1

您可以使用 System.Linq.Expressions.Expression生成与事件签名匹配的动态处理程序的类 - 您只需在其中调用 Console.WriteLine .

Expression.Lambda 方法(已提供指向您需要的特定重载的链接)可用于生成 Func<>或者，更有可能的是 Action<>类型正确。

您反射(reflect)事件的委托(delegate)类型(如@Davio 所述，获取它的 Invoke 方法)以提取所有参数并创建 ParameterExpression s 用于提供给 lambda 方法的每一个。

这是一个完整的解决方案，您可以将其粘贴到标准单元测试中，我将在之后的后续编辑中进行解释:

public class TestWithEvents
{
  //just using random delegate signatures here
  public event Action Handler1;
  public event Action<int, string> Handler2;

  public void RaiseEvents(){
    if(Handler1 != null)
        Handler1();
    if(Handler2 != null)
      Handler2(0, "hello world");
  }
}

public static class DynamicEventBinder
{
  public static Delegate GetHandler(System.Reflection.EventInfo ev) {
    string name = ev.Name;
    // create an array of ParameterExpressions
    // to pass to the Expression.Lambda method so we generate
    // a handler method with the correct signature.
    var parameters = ev.EventHandlerType.GetMethod("Invoke").GetParameters().
      Select((p, i) => Expression.Parameter(p.ParameterType, "p" + i)).ToArray();

    // this and the Compile() can be turned into a one-liner, I'm just
    // splitting it here so you can see the lambda code in the Console
    // Note that we use the Event's type for the lambda, so it's tightly bound
    // to that event.
    var lambda = Expression.Lambda(ev.EventHandlerType,
      Expression.Call(typeof(Console).GetMethod(
        "WriteLine",
        BindingFlags.Public | BindingFlags.Static,
        null,
        new[] { typeof(string) },
        null), Expression.Constant(name + " was fired!")), parameters);

    //spit the lambda out (for bragging rights)
    Console.WriteLine(
      "Compiling dynamic lambda {0} for event \"{1}\"", lambda, name);
    return lambda.Compile();
  }

  //note - an unsubscribe might be handy - which would mean
  //caching all the events that were subscribed for this object
  //and the handler.  Probably makes more sense to turn this type
  //into an instance type that binds to a single object...
  public static void SubscribeAllEvents(object o){
    foreach(var e in o.GetType().GetEvents())
    {
      e.AddEventHandler(o, GetHandler(e));
    }
  }
}

[TestMethod]
public void TestSubscribe()
{
  TestWithEvents testObj = new TestWithEvents();
  DynamicEventBinder.SubscribeAllEvents(testObj);
  Console.WriteLine("Raising events...");
  testObj.RaiseEvents();
  //check the console output
}

大纲——我们从一个有一些事件的类型开始(我正在使用 Action 但它应该适用于任何东西)，并且有一个我们可以用来测试触发所有那些有订阅者的事件的方法。

然后到DynamicEventBinder类，它有两个方法:GetHandler - 为特定类型的特定事件获取处理程序；和 SubscribeAllEvents它为该类型的给定实例绑定(bind)所有这些事件——它简单地遍历所有事件，调用 AddEventHandler对于每个，调用 GetHandler获取处理程序。

GetHandler方法是核心所在 - 并且完全按照我在大纲中的建议进行。

委托(delegate)类型有一个 Invoke成员由编译器编译到其中，它反射(reflect)了它可以绑定(bind)到的任何处理程序的签名。因此，我们反射(reflect)该方法并获取它具有的任何参数，创建 Linq ParameterExpression每个实例。命名参数很巧妙，重要的是这里的类型。

然后我们构建一个单行 lambda，其主体基本上是:

 Console.WriteLine("[event_name] was fired!");

(注意这里事件的名称被拉入动态代码并合并到一个常量字符串中，就代码而言)

当我们构建 lambda 时，我们还告诉 Expression.Lambda方法我们打算构建的委托(delegate)类型(直接绑定(bind)到事件的委托(delegate)类型)，并通过传递 ParameterExpression我们之前创建的数组，它会生成一个有那么多参数的方法。我们使用 Compile实际编译动态代码的方法，它给我们一个 Delegate然后我们可以将其用作 AddEventHandler 的参数.

我真诚地希望这能解释我们所做的事情 - 如果您在表达式和动态代码成为令人费解的东西之前没有使用过它。事实上，与我共事的一些人只是简单地称之为巫术。