Créer DynamicMethod d'Action <T> instructions

Question

Je jouais avec DynamicMethod et visent à faire ce qui suit:

J'ai une action dont j'obtenir le code IL en octets en utilisant GetILAsByteArray(). A partir de ces octets, je voudrais créer une méthode dynamique et exécuter est. Voici un exemple de ce que je suis en train de faire:

class Program 
{ 
    static void Main(string[] args) 
    { 
     //Create action and execute 
     Action<string> myAction = s => 
     { 
      Console.WriteLine("Hello " + s); 
     }; 
     myAction("World"); 
     //Get IL bytes 
     byte[] ilBytes = myAction.GetMethodInfo().GetMethodBody().GetILAsByteArray(); 
     DynamicMethod dynamicCallback = new DynamicMethod("myAction", typeof(void), new Type[] { typeof(string) }); 
     DynamicILInfo dynamicIlInfo = dynamicCallback.GetDynamicILInfo(); 
     dynamicIlInfo.SetCode(ilBytes, 100); 
     dynamicCallback.Invoke(null, new object[] { "World" }); 
    } 
} 

Lorsque vous appelez un dynamicCallback.Invoke(null, new object[] { "World" }) nous obtenons « Exception lancée: « System.BadImageFormatException » dans mscorlib.dll ».

Une chose que je n'ai aucune idée abut est ce que je devrais utiliser comme deuxième argument pour SetCode(), ce qui devrait être utilisé comme «maxStackSize»? Comment puis-je définir la même valeur que pour l'action initiale? Mais je suppose que ce n'est pas la raison de l'exception.

Comment puis-je créer correctement une méthode dynamique à partir des octets IL?

---

Solution

Ici, je voudrais résumer la solution complète fournie par Dudi Keleti:

static void Main(string[] args) 
{ 
    Action<string> myAction = s => 
    { 
     Console.WriteLine("Hello " + s); 
    }; 
    MethodInfo method = myAction.GetMethodInfo(); 
    object target = myAction.Target; 

    DynamicMethod dm = new DynamicMethod(
     method.Name, 
     method.ReturnType, 
     new[] {method.DeclaringType}. 
      Concat(method.GetParameters(). 
       Select(pi => pi.ParameterType)).ToArray(), 
     method.DeclaringType, 
     skipVisibility: true); 

    DynamicILInfo ilInfo = dm.GetDynamicILInfo(); 
    var body = method.GetMethodBody(); 
    SignatureHelper sig = SignatureHelper.GetLocalVarSigHelper(); 
    foreach (LocalVariableInfo lvi in body.LocalVariables) 
    { 
     sig.AddArgument(lvi.LocalType, lvi.IsPinned); 
    } 
    ilInfo.SetLocalSignature(sig.GetSignature()); 
    byte[] code = body.GetILAsByteArray(); 
    ILReader reader = new ILReader(method); 
    DynamicMethodHelper.ILInfoGetTokenVisitor visitor = new DynamicMethodHelper.ILInfoGetTokenVisitor(ilInfo, code); 
    reader.Accept(visitor); 
    ilInfo.SetCode(code, body.MaxStackSize); 

    dm.Invoke(target, new object[] { target, "World" }); 

    Console.ReadLine(); //Just to see the result 
} 

Note: DynamicMethodHelper est classe développée par Haibo Luo et décrit dans un blog post mais peut également être téléchargé directement here.

Answer 1

Vous pouvez le faire comme ceci:

byte[] code = body.GetILAsByteArray(); 
ILReader reader = new ILReader(method); 
ILInfoGetTokenVisitor visitor = new ILInfoGetTokenVisitor(ilInfo, code); 
reader.Accept(visitor); 
ilInfo.SetCode(code, body.MaxStackSize); 

ILReader est une classe qui font le travail pour vous. Vous pouvez le copier à partir du here.

Exemple:

MethodInfo method = ... 
DynamicMethod dm = new DynamicMethod(
    method.Name, 
    method.ReturnType, 
    method.GetParameters.Select(pi => pi.ParameterType).ToArray(), 
    method.DeclaringType, 
    skipVisibility: true\fasle - depends of your need); 

DynamicILInfo ilInfo = dm.GetDynamicILInfo(); 
var body = method.GetMethodBody(); 
SignatureHelper sig = SignatureHelper.GetLocalVarSigHelper(); 
foreach(LocalVariableInfo lvi in body.LocalVariables) 
{ 
    sig.AddArgument(lvi.LocalType, lvi.IsPinned); 
} 
ilInfo.SetLocalSignature(sig.GetSignature()); 
byte[] code = body.GetILAsByteArray(); 
ILReader reader = new ILReader(method); 
ILInfoGetTokenVisitor visitor = new ILInfoGetTokenVisitor(ilInfo, code); 
reader.Accept(visitor); 
ilInfo.SetCode(code, body.MaxStackSize); 

Si votre méthode est une méthode simple (non générique et sans poignées exception), thid devrait fonctionner.

Si votre méthode est générique, vous devez le faire pour passer le type de propriétaire au constructeur DynamicMethod:

var owner = method.DeclaringType.MakeGenericType(
      method.DeclaringType.GetGenericArguments()); 

une chose, si elle ne fonctionne toujours pas, et votre méthode est une instance méthode, passez le type instacne de la méthode dans la première cellule du tableau de paramètres du constructeur DynamicMethod.

Mise à jour

Vous ne pouvez pas passer null ici dm.Invoke(**null**, new object[] { "World" }); parce myAction n'est pas une méthode statique.

myAction (Action<string>) est en fait une méthode dans une nouvelle classe générée qui contient cette méthode.

Mais j'ai vérifié et l'exception est lancée même si je passe myAction.Target ou une nouvelle instance de ce type. L'exception (CLR dédier un programme invalide) vous indique que l'IL n'est pas exactement correcte.Je ne peux pas vous dire maintenant exactement quel est le problème, mais si c'est important pour vous, je peux le vérifier la semaine prochaine quand je vais retourner au travail.

Quoi qu'il en soit si vous voulez juste pour voir le DynamicIlInfo.SetCode en action, vous pouvez utiliser votre code comme il est, mais il suffit de changer les informations de méthode de ceci:

class Program 
{   
    static void Main(string[] args) 
    { 
     Action<string> myAction = s => 
     { 
      Console.WriteLine("Hello " + s); 
     }; 
     MethodInfo method = myAction.GetMethodInfo(); 

     //Rest of your code 
    } 
} 

à ceci:

class Program 
{ 
    static void M(string s) 
    { 
     Console.WriteLine("Hello " + s); 
    } 

    static void Main(string[] args) 
    { 
     MethodInfo method = typeof (Program).GetMethod("M", BindingFlags.Static | BindingFlags.NonPublic); 

     //Rest of your code 
    } 
} 

Mise à jour 2:

Apparemment, j'étais très fatigué hier, je n'ai pas réalisé votre erreur.

Comme je l'ai écrit dans ma première réponse,

une chose, si elle ne fonctionne toujours pas, et votre méthode est une méthode d'instance, passer le type instacne de la méthode dans la première cellule des paramters tableau du constructeur DynamicMethod.

donc vous devez faire ceci:

DynamicMethod dm = new DynamicMethod(
    method.Name, 
    method.ReturnType, 
    new[] {method.DeclaringType}. 
     Concat(method.GetParameters(). 
     Select(pi => pi.ParameterType)).ToArray(), 
    method.DeclaringType, 
    skipVisibility: true); 

Et invoquez la méthode dynamique comme ceci:

dm.Invoke(myAction.Target, new object[] { myAction.Target, "World" }); 

Maintenant, il est un travail parfait.