C# Dynamic Event Subscription

Question

How would you dynamically subscribe to a C# event so that given a Object instance and a String name containing the name of the event, you subscribe to that event and do something (write to the console for example) when that event has been fired?

It would seem using Reflection this isn't possible and I would like to avoid having to use Reflection.Emit if possible, as this currently (to me) seems like the only way of doing it.

/EDIT: I do not know the signature of the delegate needed for the event, this is the core of the problem

/EDIT 2: Although delegate contravariance seems like a good plan, I can not make the assumption necessary to use this solution

Answer 1

You can compile expression trees to use void methods without any arguments as event handlers for events of any type. To accommodate other event handler types, you have to map the event handler's parameters to the events somehow.

 using System;  using System.Linq;  using System.Linq.Expressions;  using System.Reflection;   class ExampleEventArgs : EventArgs  {     public int IntArg {get; set;}  }   class EventRaiser  {       public event EventHandler SomethingHappened;      public event EventHandler<ExampleEventArgs> SomethingHappenedWithArg;       public void RaiseEvents()      {          if (SomethingHappened!=null) SomethingHappened(this, EventArgs.Empty);           if (SomethingHappenedWithArg!=null)           {             SomethingHappenedWithArg(this, new ExampleEventArgs{IntArg = 5});          }      }  }   class Handler  {       public void HandleEvent() { Console.WriteLine("Handler.HandleEvent() called.");}      public void HandleEventWithArg(int arg) { Console.WriteLine("Arg: {0}",arg);    }  }   static class EventProxy  {       //void delegates with no parameters      static public Delegate Create(EventInfo evt, Action d)      {           var handlerType = evt.EventHandlerType;          var eventParams = handlerType.GetMethod("Invoke").GetParameters();           //lambda: (object x0, EventArgs x1) => d()          var parameters = eventParams.Select(p=>Expression.Parameter(p.ParameterType,"x"));          var body = Expression.Call(Expression.Constant(d),d.GetType().GetMethod("Invoke"));          var lambda = Expression.Lambda(body,parameters.ToArray());          return Delegate.CreateDelegate(handlerType, lambda.Compile(), "Invoke", false);      }       //void delegate with one parameter      static public Delegate Create<T>(EventInfo evt, Action<T> d)      {          var handlerType = evt.EventHandlerType;          var eventParams = handlerType.GetMethod("Invoke").GetParameters();           //lambda: (object x0, ExampleEventArgs x1) => d(x1.IntArg)          var parameters = eventParams.Select(p=>Expression.Parameter(p.ParameterType,"x")).ToArray();          var arg    = getArgExpression(parameters[1], typeof(T));          var body   = Expression.Call(Expression.Constant(d),d.GetType().GetMethod("Invoke"), arg);          var lambda = Expression.Lambda(body,parameters);          return Delegate.CreateDelegate(handlerType, lambda.Compile(), "Invoke", false);      }       //returns an expression that represents an argument to be passed to the delegate      static Expression getArgExpression(ParameterExpression eventArgs, Type handlerArgType)      {         if (eventArgs.Type==typeof(ExampleEventArgs) && handlerArgType==typeof(int))         {            //"x1.IntArg"            var memberInfo = eventArgs.Type.GetMember("IntArg")[0];            return Expression.MakeMemberAccess(eventArgs,memberInfo);         }          throw new NotSupportedException(eventArgs+"->"+handlerArgType);      }  }    static class Test  {      public static void Main()      {          var raiser  = new EventRaiser();         var handler = new Handler();          //void delegate with no parameters         string eventName = "SomethingHappened";         var eventinfo = raiser.GetType().GetEvent(eventName);         eventinfo.AddEventHandler(raiser,EventProxy.Create(eventinfo,handler.HandleEvent));          //void delegate with one parameter         string eventName2 = "SomethingHappenedWithArg";         var eventInfo2 = raiser.GetType().GetEvent(eventName2);         eventInfo2.AddEventHandler(raiser,EventProxy.Create<int>(eventInfo2,handler.HandleEventWithArg));          //or even just:         eventinfo.AddEventHandler(raiser,EventProxy.Create(eventinfo,()=>Console.WriteLine("!")));           eventInfo2.AddEventHandler(raiser,EventProxy.Create<int>(eventInfo2,i=>Console.WriteLine(i+"!")));          raiser.RaiseEvents();      }  } 

Answer 2

It's not a completely general solution, but if all your events are of the form void Foo(object o, T args) , where T derives from EventArgs, then you can use delegate contravariance to get away with it. Like this (where the signature of KeyDown is not the same as that of Click) :

    public Form1()     {         Button b = new Button();         TextBox tb = new TextBox();          this.Controls.Add(b);         this.Controls.Add(tb);         WireUp(b, "Click", "Clickbutton");         WireUp(tb, "KeyDown", "Clickbutton");     }      void WireUp(object o, string eventname, string methodname)     {         EventInfo ei = o.GetType().GetEvent(eventname);          MethodInfo mi = this.GetType().GetMethod(methodname, BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);          Delegate del = Delegate.CreateDelegate(ei.EventHandlerType, this, mi);          ei.AddEventHandler(o, del);      }     void Clickbutton(object sender, System.EventArgs e)     {         MessageBox.Show("hello!");     }