Créer une méthode dynamique et l'exécuter

Si je prends la méthode suivante:

public static int Multiply(int a, int b)
{
    return a * b;
}

compiler en mode Release et à utiliser dans votre code, tout fonctionne bien. Et si je inspecter l' il array, il contient 4 octets qui correspondent exactement aux quatre instructions de Jon réponse (ldarg.0, ldarg.1, mul, ret).

si je le compile en mode debug, le code est de 9 octets. Et dans le Réflecteur, il ressemble à ceci:

.method public hidebysig static int32 Multiply(int32 a, int32 b) cil managed
{
    .maxstack 2
    .locals init (
        [0] int32 CS00)
    L_0000: nop 
    L_0001: ldarg.0 
    L_0002: ldarg.1 
    L_0003: mul 
    L_0004: stloc.0 
    L_0005: br.s L_0007
    L_0007: ldloc.0 
    L_0008: ret 
}

la partie problématique est la variable locale. Si vous venez de copier les octets d'instruction, vous émettez l'instruction qui utilise une variable locale, mais vous ne la déclarez jamais.

Si vous utilisez ILGenerator, vous pouvez utiliser DeclareLocal(). Il semble que vous serez capable de définir des variables locales en utilisant MethodBuilder.SetMethodBody().Net 4.5 (travaux ci-après pour moi de VS 11 DP):

var module = typeof(Experiment).Module;
mb.SetMethodBody(il, methodBody.MaxStackSize,
                 module.ResolveSignature(methodBody.LocalSignatureMetadataToken),
                 null, null);

mais je n'ai pas trouvé le moyen de le faire dans .Net 4, sauf en utilisant la réflexion pour définir un champ privé de MethodBuilder, qui contient les variables locales, après appel CreateMethodBody():

typeof(MethodBuilder)
    .GetField("m_localSignature", BindingFlags.NonPublic | BindingFlags.Instance)
    .SetValue(mb, module.ResolveSignature(methodBody.LocalSignatureMetadataToken));

en ce qui concerne l'erreur initiale: Types et méthodes d'autres assemblages (comme System.Console et System.Console.WriteLine) sont référencés en utilisant des tokens. Et ces signes sont différents d'une assemblée à l'autre. Que signifie le code pour appeler Console.WriteLine() dans un assemblage sera différent du code pour appeler la même méthode dans un autre assemblage, si vous regardez les octets d'instruction.

ce que cela signifie est que vous devez réellement comprendre ce que les octets IL signifient et remplacer tous les tokens qui font référence aux types, méthodes, etc. à ceux qui sont valides dans l'assemblée que vous construisez.

je pense que le problème est d'utiliser IL d'un type/assemblage dans un autre. Si vous remplacez ceci:

mb.CreateMethodBody(il, il.Count());

avec ceci:

ILGenerator generator = mb.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Mul);
generator.Emit(OpCodes.Ret);

puis il exécutera la méthode correctement (Non Console.WriteLine, mais il retourne la bonne valeur).

si vous avez vraiment besoin d'être en mesure de slurp IL à partir d'une méthode existante, vous aurez besoin de regarder plus loin - mais si vous avez juste besoin de validation que le reste du code fonctionnait, cela peut aider.

Une chose que vous pouvez trouver intéressant est que l'erreur change dans votre code original Si vous prenez le Console.WriteLine appel de Experiment. Il devient un InvalidProgramException à la place. Je n'ai aucune idée pourquoi...

si je comprends bien votre problème, et que vous voulez juste générer dynamiquement un peu de code .NET, et l'exécuter sur un client distant, maeby jeter un oeil à IronPython. Vous avez juste besoin de créer une chaîne de caractères avec le script puis de l'envoyer au client, et le client peut l'exécuter à l'exécution avec l'accès à tout le Framework .NET, même interférer avec votre application client à l'exécution.

il y a un moyen difficile d'obtenir la méthode de "copie" et cela prendra du temps.

regardez ILSpy, cette application est utilisée pour visualiser et analyser le code existant et est open-source. Vous pouvez extraire le code du projet qui est utilisé pour analyser le code IL-ASM et l'utiliser pour copier la méthode.

cette réponse est un peu orthogonale - plus sur le problème que la technologie impliquée.

vous pourriez utiliser des arbres d'expression-ils sont agréables à travailler et ont VS sucre syntaxique.

Pour la sérialisation vous avez besoin de cette bibliothèque (vous aurez besoin de compiler trop): http://expressiontree.codeplex.com/

la limitation des arbres d'expression est qu'ils ne supportent que Lambda expressions - c'est à dire pas de blocs.

ce n'est pas vraiment une limitation car vous pouvez encore définir d'autres méthodes lambda au sein d'une lambda et les passer à des helpers de programmation fonctionnelle tels que L'API Linq.

j'ai inclus une méthode d'extension simple pour vous montrer comment aller sur l'ajout d'autres méthodes d'aide pour les trucs fonctionnels - le point clé est que vous devez inclure les assemblages contenant les extensions dans votre serializer.

ce code fonctionne:

using System;
using System.Linq;
using System.Linq.Expressions;
using ExpressionSerialization;
using System.Xml.Linq;
using System.Collections.Generic;
using System.Reflection;

namespace ExpressionSerializationTest
{
    public static class FunctionalExtensions
    {
        public static IEnumerable<int> to(this int start, int end)
        {
            for (; start <= end; start++)
                yield return start;
        }
    }

    class Program
    {
        private static Expression<Func<int, int, int>> sumRange = 
            (x, y) => x.to(y).Sum();

        static void Main(string[] args)
        {
            const string fileName = "sumRange.bin";

            ExpressionSerializer serializer = new ExpressionSerializer(
                new TypeResolver(new[] { Assembly.GetExecutingAssembly() })
            );

            serializer.Serialize(sumRange).Save(fileName);

            Expression<Func<int, int, int>> deserializedSumRange =
                serializer.Deserialize<Func<int, int, int>>(
                    XElement.Load(fileName)
                );

            Func<int, int, int> funcSumRange = 
                deserializedSumRange.Compile();

            Console.WriteLine(
                "Deserialized func returned: {0}", 
                funcSumRange(1, 4)
            );

            Console.ReadKey();
        }
    }
}