Génération d'événements dynamiques en C# avec DynamicMethod et ILGenerator

Question

J'ai besoin de générer un gestionnaire d'événements basé sur un objet EventInfo en exécution et d'appeler une méthode dans ce gestionnaire d'événements. Quelque chose comme le suivant:

public void RegisterAction(ActionData actionData, EventInfo eventInfo, 
    Control control) 
{ 
    MethodInfo methodInfo = eventInfo.EventHandlerType.GetMethod("Invoke"); 

    List<Type> ps = new List<Type>(); 
    foreach (ParameterInfo info in methodInfo.GetParameters()) 
    { 
     ps.Add(info.ParameterType); 
    } 

    DynamicMethod method = new DynamicMethod("Adapter", 
               typeof (void), 
               ps.ToArray(), 
               GetType(), 
               true); 

    ILGenerator generator = method.GetILGenerator(); 

    // Here I need to generate a method to do the following: 
    // ExecuteAction(actionData); 

    // Then I can use this runtime method as an event handler and 
    // bind it to the control 
    Delegate proxy = method.CreateDelegate(eventInfo.EventHandlerType, this); 

    eventInfo.AddEventHandler(control, proxy); 
} 

J'ai besoin d'aide pour générer le code IL pour la partie commentée.

Answer 1

public void RegisterAction(ActionData actionData, EventInfo eventInfo, 
    Control control) 
{ 
    MethodInfo methodInfo = eventInfo.EventHandlerType.GetMethod("Invoke"); 

    List<Type> ps = new List<Type>(); 
    ps.Add (typeof (ActionData)) ; 
    foreach (ParameterInfo info in methodInfo.GetParameters()) 
    { 
     ps.Add(info.ParameterType); 
    } 

    DynamicMethod method = new DynamicMethod("Adapter", 
               typeof (void), 
               ps.ToArray(), 
               GetType(), 
               true); 

    // compatible signatures for ExecuteAction 
    // (assuming you aren't interested in sender and eventArgs): 
    // static void ExecuteAction (ActionData) ; 
    // void ActionData.ExecuteAction() ; 
    MethodInfo miExecuteAction = <...> ; 
    ILGenerator generator = method.GetILGenerator(); 
    generator.Emit (OpCodes.Ldarg_0) ; 
    generator.Emit (OpCodes.Call, miExecuteAction) ; 
    generator.Emit (OpCodes.Ret) ; 

    // if you want to pass this to ExecuteAction, 
    // you'll need to put it into actionData. 
    Delegate proxy = method.CreateDelegate(eventInfo.EventHandlerType, actionData); 

    eventInfo.AddEventHandler(control, proxy); 
} 

Modifier: venez y penser, si tous vos événements suivent le modèle (expéditeur, args), vous ne même pas besoin de faire jouer avec SRE:

public static void Execute<T> (ActionData data, object sender, T args) 
    where T : EventArgs 
{ 
    ExecuteAction (data) ; 
} 

public void RegisterAction (ActionData actionData, EventInfo eventInfo, 
    Control control) 
{ 
    MethodInfo compatibleMethod = typeof (this).GetMethod ("Execute", 
     BindingFlags.Static | BindingFlags.Public).MakeGenericMethod (
     eventInfo.EventHandlerType.GetMethod ("Invoke").GetParameters()[1].ParameterType)) ; 
    eventInfo.AddEventHandler (control, 
     Delegate.CreateDelegate (eventInfo.EventHandlerType, actionData, 
     compatibleMethod)) ; 
} 

Answer 2

Je devine que vous voulez faire un délégué de la MethodInfo de votre événement ...

Si oui, here is an article décrivant comment s'y prendre. Les codes IL requis sont expliqués dans cet article.