Créer une fonction de manière dynamique au moment de l'exécution

Votre question est assez difficile, mais vous pouvez certainement utiliser des arbres d'expression pour créer des délégués de manière dynamique au moment de l'exécution. (Il y a d'autres façons de le faire tels que CodeDom, mais les arbres d'expression sont handtiques si em> ils font tout ce dont vous avez besoin. Il existe toutefois des restrictions significatives à ce que vous pouvez faire, ce que vous pouvez faire ce que vous pouvez faire.)

C'est souvent plus facile Pour utiliser une expression de Lambda avec des variables capturées cependant. p>

Par exemple, pour créer une fonction qui ajoutera la quantité spécifiée à n'importe quel entier, vous pouvez écrire: p>

static Func<int, int> CreateAdder(int amountToAdd)
{
    return x => x + amountToAdd;
}

...
var adder = CreateAdder(10);
Console.WriteLine(adder(5)); // Prints 15

Vous avez plusieurs façons de le faire:

• Créez de manière dynamique une expression de Lambda (regardez Dynamic Linq: Partie 1 )
• créer de manière dynamique du modèle de code et le compilez à l'heure d'exécution (regardez Espace de noms codedom.comPiler
• Créez de manière dynamique C # / VB.NET CODE SOURCE et compilez-la à l'heure d'exécution (regardez csharpcodeprovider et VBCodeProvider cours)
• Créez de manière dynamique un modèle d'objet, qui peut faire les mêmes choses comme la méthode (regarder modèle de conception de stratégie

Le plus rapide (je crois, en 3.5) est de créer un DynamicMethod . C'est aussi la méthode la plus effrayante. Vous construisez essentiellement une méthode utilisant IL, qui a à peu près la même sensation que d'écrire du code dans la langue de la machine.

J'avais besoin de le faire pour attacher de manière dynamique des gestionnaires d'événements dans une chose ou une autre (Eh bien, je n'avais pas besoin de le faire, je voulais juste faciliter les événements de test de l'unité). Il semblait un peu décourageant à l'époque parce que je ne connais pas la merde d'IL, mais j'ai compris un moyen simple d'accomplir cela.

Ce que vous faites est de créer une méthode qui fait exactement ce que vous voulez. Plus le mieux compact. Je fournirais un exemple si je pouvais comprendre exactement ce que vous essayez de faire. Vous écrivez cette méthode dans une classe dans un projet DLL et la compilez en mode de sortie. Ensuite, vous ouvrez la DLL dans le réflecteur et désassemblez votre méthode. Le réflecteur vous donne la possibilité de quelle langue vous souhaitez démonter pour - sélectionner IL. Vous avez maintenant les appels exacts dont vous avez besoin pour ajouter à votre méthode dynamique. Suivez simplement l'exemple sur MSDN, éteignez l'exemple de l'exemple pour votre code de méthodes réfléchi.

Les méthodes dynamiques, une fois construites, invoquent à peu près la même vitesse que les méthodes compilées (ont vu un test dans lequel des méthodes dynamiques pourraient être appelées à environ 20 ms où la réflexion a pris plus de 200 ms).

Je ne recommande pas cela sur les autres mieux les options em>, mais il y a une méthode 7 ^{TH sup> et c'est à utiliser AssemblyBuilder Code>, ModuleBuilder Code>, TypeBuilder Code> et MethodBuilder Code> Dans le System.reflection.emit code> Espace de noms pour créer un assemblage dynamique. C'est le même Voodoo similaire que l'utilisation dynamicmethod code>.}

Par exemple, vous pouvez les utiliser pour créer une classe proxy pour un type et une autre méthode virtuelle sur ce type. p>

Pour vous aider à démarrer Voici est un code ... P>

using System;
using System.Reflection;
using System.Reflection.Emit;

var myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(
        new AssemblyName("Test"), AssemblyBuilderAccess.RunAndSave);
var myModule = myAssembly.DefineDynamicModule("Test.dll");
var myType = myModule.DefineType("ProxyType", TypeAttributes.Public | TypeAttributes.Class,
                        typeof(TypeToSeverelyModifyInAnUglyWayButItsNecessary));
var myMethod = myType.DefineMethod("MethodNameToOverride", 
                        MethodAttributes.HideBySig | MethodAttributes.Public,
                        typeof(void),Type.EmptyTypes);
var myIlGenerator = myMethod.GetILGenerator();
myIlGenerator.Emit(OpCodes.Ret);
var type = myType.CreateType();

Si vous déclarez la méthode de Virtual, vous pourrez peut-être utiliser Castle's dynamicproxy Pour substituer une mise en œuvre générée dynamiquement (avec l'une des méthodes de la réponse) à l'exécution:

Castle DynamicProxy est une bibliothèque pour générer des proxies de la Lightweight .NET à la volée au moment de l'exécution. Les objets proxy permettent des appels aux membres d'un objet à intercepter sans modifier le code de la classe. Les classes et les interfaces peuvent être proxoées, mais seuls les membres virtuels peuvent être interceptés.

Le deuxième paragraphe de votre question suggère que vraiment ce que vous pourriez être après est directement ioc (Inversion de contrôle)

Au lieu de déclarer une instance de votre classe, vous déclarez une instance d'une interface et basée sur la condition que vous choisissez, vous utilisez la classe principale particulière avec la méthode correcte. J'espère que cela a du sens.

Vous devez vérifier si votre problème peut être résolu avec un simple polymorphisme d'abord. Sauf si vous définissez une interopérabilité abstraite à une autre langue ou à éditer le compilateur, essayez de modifier une méthode à l'exécution est probablement la solution incorrecte au problème.

Utilisez .NET CORE 3.1, vous pouvez créer une méthode dynamique avec la langue de l'IL (mono est la même):

using System.Linq.Expressions;
using System.Reflection.Emit;

class Program
{
    static void Main()
    {
        DynamicMethod hellomethod = new DynamicMethod("WriteLine", typeof(void), new[] { typeof(string) }, typeof(Program).Module);
        ILGenerator il = hellomethod.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }));
        il.Emit(OpCodes.Ret);
        Action<string> hello4 = (Action<string>)hellomethod.CreateDelegate(typeof(Action<string>));
        hello4("Hello World!");
    }
}