Guide pratique pour définir une méthode générique avec l’émission de réflexion

La première procédure montre comment créer une méthode générique simple avec deux paramètres de type et comment appliquer des contraintes de classe, des contraintes d’interface et des contraintes spéciales aux paramètres de type.

La deuxième procédure montre comment émettre le corps de la méthode et comment utiliser les paramètres de type de la méthode générique pour créer des instances de types génériques et appeler leurs méthodes.

La troisième procédure montre comment appeler la méthode générique.

Importante

Une méthode n’est pas générique uniquement parce qu’elle appartient à un type générique et utilise les paramètres de type de ce type. Une méthode est générique uniquement si elle possède sa propre liste de paramètres de type. Une méthode générique peut apparaître sur un type non générique, comme dans cet exemple. Pour obtenir un exemple de méthode non générique sur un type générique, consultez How to : Define a Generic Type with Reflection Emit.

Définir une méthode générique

1. Avant de commencer, il est utile de voir comment la méthode générique apparaît quand elle est écrite à l’aide d’un langage de haut niveau. Le code suivant est inclus dans l’exemple de code de cet article, ainsi que le code permettant d’appeler la méthode générique. La méthode a deux paramètres de type, TInput et TOutput, dont le deuxième doit être un type référence (class), posséder un constructeur sans paramètre (new), et implémenter ICollection<TInput>. Cette contrainte d’interface garantit que la ICollection<T>.Add méthode peut être utilisée pour ajouter des éléments à la TOutput collection créée par la méthode. La méthode a un paramètre formel, inputqui est un tableau de TInput. La méthode crée une collection de type TOutput et copie les éléments de input à la collection.

   public static TOutput Factory<TInput, TOutput>(TInput[] tarray)
       where TOutput : class, ICollection<TInput>, new()
   {
       TOutput ret = new TOutput();
       ICollection<TInput> ic = ret;
   
       foreach (TInput t in tarray)
       {
           ic.Add(t);
       }
       return ret;
   }
   

   Public Shared Function Factory(Of TInput, _
       TOutput As {ICollection(Of TInput), Class, New}) _
       (ByVal input() As TInput) As TOutput
   
       Dim retval As New TOutput()
       Dim ic As ICollection(Of TInput) = retval
   
       For Each t As TInput In input
           ic.Add(t)
       Next
   
       Return retval
   End Function
   

2. Définissez un assembly dynamique et un module dynamique pour contenir le type auquel appartient la méthode générique. Dans ce cas, l’assembly n’a qu’un seul module, nommé DemoMethodBuilder1et le nom du module est identique au nom de l’assembly et à une extension. Dans cet exemple, l’assembly est enregistré sur le disque et également exécuté, c'est pourquoi AssemblyBuilderAccess.RunAndSave est spécifié. Vous pouvez utiliser le Ildasm.exe (désassembleur IL) pour examiner DemoMethodBuilder1.dll et le comparer au langage intermédiaire commun (CIL) pour la méthode indiquée à l’étape 1.

   AssemblyName asmName = new AssemblyName("DemoMethodBuilder1");
   AppDomain domain = AppDomain.CurrentDomain;
   AssemblyBuilder demoAssembly =
       domain.DefineDynamicAssembly(asmName,
           AssemblyBuilderAccess.RunAndSave);
   
   // Define the module that contains the code. For an
   // assembly with one module, the module name is the
   // assembly name plus a file extension.
   ModuleBuilder demoModule =
       demoAssembly.DefineDynamicModule(asmName.Name,
           asmName.Name+".dll");
   

   Dim asmName As New AssemblyName("DemoMethodBuilder1")
   Dim domain As AppDomain = AppDomain.CurrentDomain
   Dim demoAssembly As AssemblyBuilder = _
       domain.DefineDynamicAssembly(asmName, _
           AssemblyBuilderAccess.RunAndSave)
   
   ' Define the module that contains the code. For an 
   ' assembly with one module, the module name is the 
   ' assembly name plus a file extension.
   Dim demoModule As ModuleBuilder = _
       demoAssembly.DefineDynamicModule( _
           asmName.Name, _
           asmName.Name & ".dll")
   

3. Définissez le type auquel appartient la méthode générique. Le type n’a pas besoin d’être générique. Une méthode générique peut appartenir à un type générique ou non générique. Dans cet exemple, le type est une classe, n’est pas générique et est nommé DemoType.

   TypeBuilder demoType =
       demoModule.DefineType("DemoType", TypeAttributes.Public);
   

   Dim demoType As TypeBuilder = demoModule.DefineType( _
       "DemoType", _
       TypeAttributes.Public)
   

4. Définissez la méthode générique. Si les types des paramètres formels d’une méthode générique sont spécifiés par les paramètres de type générique de la méthode générique, utilisez la DefineMethod(String, MethodAttributes) surcharge de méthode pour définir la méthode. Les paramètres de type générique de la méthode ne sont pas encore définis. Vous ne pouvez donc pas spécifier les types des paramètres formels de la méthode dans l’appel à DefineMethod. Dans cet exemple, la méthode est nommée Factory. La méthode est publique et static (Shared en Visual Basic).

   MethodBuilder factory =
       demoType.DefineMethod("Factory",
           MethodAttributes.Public | MethodAttributes.Static);
   

   Dim factory As MethodBuilder = _
       demoType.DefineMethod("Factory", _
           MethodAttributes.Public Or MethodAttributes.Static)
   

5. Définissez les paramètres de type générique de DemoMethod en transmettant à la méthode MethodBuilder.DefineGenericParameters un tableau de chaînes contenant les noms des paramètres. Cela rend la méthode générique. Le code suivant rend Factory une méthode générique avec les paramètres de type TInput et TOutput. Pour faciliter la lecture du code, les variables avec ces noms sont créées pour contenir les GenericTypeParameterBuilder objets représentant les deux paramètres de type.

   string[] typeParameterNames = {"TInput", "TOutput"};
   GenericTypeParameterBuilder[] typeParameters =
       factory.DefineGenericParameters(typeParameterNames);
   
   GenericTypeParameterBuilder TInput = typeParameters[0];
   GenericTypeParameterBuilder TOutput = typeParameters[1];
   

   Dim typeParameterNames() As String = {"TInput", "TOutput"}
   Dim typeParameters() As GenericTypeParameterBuilder = _
       factory.DefineGenericParameters(typeParameterNames)
   
   Dim TInput As GenericTypeParameterBuilder = typeParameters(0)
   Dim TOutput As GenericTypeParameterBuilder = typeParameters(1)
   

6. Ajoutez éventuellement des contraintes spéciales aux paramètres de type. Des contraintes spéciales sont ajoutées à l’aide de la SetGenericParameterAttributes méthode. Dans cet exemple, TOutput il est contraint d’être un type de référence et d’avoir un constructeur sans paramètre.

   TOutput.SetGenericParameterAttributes(
       GenericParameterAttributes.ReferenceTypeConstraint |
       GenericParameterAttributes.DefaultConstructorConstraint);
   

   TOutput.SetGenericParameterAttributes( _
       GenericParameterAttributes.ReferenceTypeConstraint Or _
       GenericParameterAttributes.DefaultConstructorConstraint)
   

7. Ajoutez éventuellement des contraintes de classe et d’interface aux paramètres de type. Dans cet exemple, le paramètre TOutput de type est limité aux types qui implémentent l’interface ICollection(Of TInput) (ICollection<TInput> en C#). Cela garantit que la Add méthode peut être utilisée pour ajouter des éléments.

   Type icoll = typeof(ICollection<>);
   Type icollOfTInput = icoll.MakeGenericType(TInput);
   Type[] constraints = {icollOfTInput};
   TOutput.SetInterfaceConstraints(constraints);
   

   Dim icoll As Type = GetType(ICollection(Of ))
   Dim icollOfTInput As Type = icoll.MakeGenericType(TInput)
   Dim constraints() As Type = {icollOfTInput}
   TOutput.SetInterfaceConstraints(constraints)
   

8. Définissez les paramètres formels de la méthode à l’aide de la SetParameters méthode. Dans cet exemple, la Factory méthode a un paramètre, un tableau de TInput. Ce type est créé en appelant la MakeArrayType méthode sur l’objet GenericTypeParameterBuilder qui représente TInput. L'argument de SetParameters est un tableau d'objets Type.

   Type[] parms = {TInput.MakeArrayType()};
   factory.SetParameters(parms);
   

   Dim params() As Type = {TInput.MakeArrayType()}
   factory.SetParameters(params)
   

9. Définissez le type de retour de la méthode à l’aide de la SetReturnType méthode. Dans cet exemple, une instance de TOutput est retournée.

   factory.SetReturnType(TOutput);
   

   factory.SetReturnType(TOutput)
   

10. Émettez le corps de méthode à l’aide de ILGenerator. Pour plus d’informations, consultez la procédure d’émission du corps de méthode.

    Importante

    Lorsque vous émettez des appels à des méthodes de types génériques et que les arguments de type de ces types sont des paramètres de type de la méthode générique, vous devez utiliser les staticGetConstructor(Type, ConstructorInfo)surcharges de méthode , GetMethod(Type, MethodInfo)et GetField(Type, FieldInfo) les surcharges de méthode de la TypeBuilder classe pour obtenir des formes construites des méthodes. Ceci est illustré dans la procédure d’émission du corps de méthode.

11. Complétez le type qui contient la méthode et enregistrez l'assemblage. La procédure associée pour appeler la méthode générique montre deux façons d’appeler la méthode terminée.

    // Complete the type.
    Type dt = demoType.CreateType();
    // Save the assembly, so it can be examined with Ildasm.exe.
    demoAssembly.Save(asmName.Name+".dll");
    

    ' Complete the type.
    Dim dt As Type = demoType.CreateType()
    ' Save the assembly, so it can be examined with Ildasm.exe.
    demoAssembly.Save(asmName.Name & ".dll")
    

Émettez le corps de méthode

1. Obtenez un générateur de code et déclarez des variables et des étiquettes locales. La DeclareLocal méthode est utilisée pour déclarer des variables locales. La Factory méthode a quatre variables locales : retVal pour contenir le nouveau TOutput retourné par la méthode, ic pour contenir le TOutput lorsqu'il est converti en ICollection<TInput>, input pour contenir le tableau d’entrée des objets TInput, et index pour itérer dans le tableau. La méthode a également deux étiquettes, une pour entrer la boucle (enterLoop) et une pour le haut de la boucle (loopAgain), définie à l’aide de la DefineLabel méthode.

   La première chose que la méthode fait est de charger son argument à l’aide de l'opcode Ldarg_0 et de le stocker dans la variable locale input, à l’aide de l'opcode Stloc_S.

   ILGenerator ilgen = factory.GetILGenerator();
   
   LocalBuilder retVal = ilgen.DeclareLocal(TOutput);
   LocalBuilder ic = ilgen.DeclareLocal(icollOfTInput);
   LocalBuilder input = ilgen.DeclareLocal(TInput.MakeArrayType());
   LocalBuilder index = ilgen.DeclareLocal(typeof(int));
   
   Label enterLoop = ilgen.DefineLabel();
   Label loopAgain = ilgen.DefineLabel();
   
   ilgen.Emit(OpCodes.Ldarg_0);
   ilgen.Emit(OpCodes.Stloc_S, input);
   

   Dim ilgen As ILGenerator = factory.GetILGenerator()
   
   Dim retVal As LocalBuilder = ilgen.DeclareLocal(TOutput)
   Dim ic As LocalBuilder = ilgen.DeclareLocal(icollOfTInput)
   Dim input As LocalBuilder = _
       ilgen.DeclareLocal(TInput.MakeArrayType())
   Dim index As LocalBuilder = _
       ilgen.DeclareLocal(GetType(Integer))
   
   Dim enterLoop As Label = ilgen.DefineLabel()
   Dim loopAgain As Label = ilgen.DefineLabel()
   
   ilgen.Emit(OpCodes.Ldarg_0)
   ilgen.Emit(OpCodes.Stloc_S, input)
   

2. Émettez du code pour créer une instance de TOutput, en utilisant la surcharge de méthode générique de la méthode Activator.CreateInstance. L’utilisation de cette surcharge nécessite que le type spécifié ait un constructeur sans paramètre, qui est la raison de l’ajout de cette contrainte à TOutput. Créez la méthode générique construite en passant TOutput à MakeGenericMethod. Après avoir émis du code pour appeler la méthode, émettez du code pour le stocker dans la variable retVal locale à l’aide de Stloc_S

   MethodInfo createInst =
       typeof(Activator).GetMethod("CreateInstance", Type.EmptyTypes);
   MethodInfo createInstOfTOutput =
       createInst.MakeGenericMethod(TOutput);
   
   ilgen.Emit(OpCodes.Call, createInstOfTOutput);
   ilgen.Emit(OpCodes.Stloc_S, retVal);
   

   Dim createInst As MethodInfo = _
       GetType(Activator).GetMethod("CreateInstance", Type.EmptyTypes)
   Dim createInstOfTOutput As MethodInfo = _
       createInst.MakeGenericMethod(TOutput)
   
   ilgen.Emit(OpCodes.Call, createInstOfTOutput)
   ilgen.Emit(OpCodes.Stloc_S, retVal)
   

3. Émettez du code pour convertir le nouvel TOutput objet ICollection(Of TInput) et le stocker dans la variable iclocale.

   ilgen.Emit(OpCodes.Ldloc_S, retVal);
   ilgen.Emit(OpCodes.Box, TOutput);
   ilgen.Emit(OpCodes.Castclass, icollOfTInput);
   ilgen.Emit(OpCodes.Stloc_S, ic);
   

   ilgen.Emit(OpCodes.Ldloc_S, retVal)
   ilgen.Emit(OpCodes.Box, TOutput)
   ilgen.Emit(OpCodes.Castclass, icollOfTInput)
   ilgen.Emit(OpCodes.Stloc_S, ic)
   

4. Obtenez un MethodInfo représentant la méthode ICollection<T>.Add. La méthode agit sur un ICollection<TInput>, il est donc nécessaire d’obtenir la Add méthode spécifique à ce type construit. Vous ne pouvez pas utiliser la méthode GetMethod pour obtenir directement ce MethodInfo à partir de icollOfTInput, car GetMethod n'est pas pris en charge sur un type qui a été construit avec un GenericTypeParameterBuilder. Au lieu de cela, appelez GetMethod sur icoll, qui contient la définition de type générique pour l’interface générique ICollection<T>. Utilisez ensuite la GetMethod(Type, MethodInfo)static méthode pour produire le MethodInfo type construit. Le code suivant illustre cela.

   MethodInfo mAddPrep = icoll.GetMethod("Add");
   MethodInfo mAdd = TypeBuilder.GetMethod(icollOfTInput, mAddPrep);
   

   Dim mAddPrep As MethodInfo = icoll.GetMethod("Add")
   Dim mAdd As MethodInfo = _
       TypeBuilder.GetMethod(icollOfTInput, mAddPrep)
   

5. Émettez du code pour initialiser la index variable, en chargeant un entier 0 32 bits et en le stockant dans la variable. Émettre du code pour effectuer un saut vers l’étiquette enterLoop. Cette étiquette n’a pas encore été marquée, car elle se trouve à l’intérieur de la boucle. Le code de la boucle est émis à l’étape suivante.

   // Initialize the count and enter the loop.
   ilgen.Emit(OpCodes.Ldc_I4_0);
   ilgen.Emit(OpCodes.Stloc_S, index);
   ilgen.Emit(OpCodes.Br_S, enterLoop);
   

   ' Initialize the count and enter the loop.
   ilgen.Emit(OpCodes.Ldc_I4_0)
   ilgen.Emit(OpCodes.Stloc_S, index)
   ilgen.Emit(OpCodes.Br_S, enterLoop)
   

6. Émettez le code de la boucle. La première étape consiste à marquer le haut de la boucle en appelant MarkLabel avec l’étiquette loopAgain . Les instructions de branche qui utilisent l’étiquette créent désormais une branche vers ce point du code. L'étape suivante consiste à pousser l'objet TOutput, après l'avoir converti en ICollection(Of TInput), sur la pile. Il n’est pas nécessaire immédiatement, mais doit être en position d’appeler la méthode Add. Ensuite, le tableau d’entrée fait l’objet d’un push dans la pile, puis c’est au tour de la variable index qui contient l’index actuel dans le tableau. L’opcode Ldelem dépile l’index et le tableau et effectue un push de l’élément de tableau indexé dans la pile. La pile est maintenant prête pour l’appel à la méthode ICollection<T>.Add, qui dépile la collection et le nouvel élément et ajoute l’élément à la collection.

   Le reste du code de la boucle incrémente l’index et teste pour voir si la boucle est terminée : l’index et un entier 32 bits 1 sont poussés sur la pile et ajoutés, laissant la somme sur la pile ; la somme est stockée dans index. MarkLabel est appelé pour définir ce point comme point d’entrée pour la boucle. L’index est à nouveau chargé. Le tableau d’entrée fait l’objet d’un push dans la pile et Ldlen est émis pour obtenir sa longueur. L’index et la longueur se trouvent maintenant sur la pile et Clt est émis pour les comparer. Si l’index est inférieur à la longueur, Brtrue_S retourne au début de la boucle.

   ilgen.MarkLabel(loopAgain);
   
   ilgen.Emit(OpCodes.Ldloc_S, ic);
   ilgen.Emit(OpCodes.Ldloc_S, input);
   ilgen.Emit(OpCodes.Ldloc_S, index);
   ilgen.Emit(OpCodes.Ldelem, TInput);
   ilgen.Emit(OpCodes.Callvirt, mAdd);
   
   ilgen.Emit(OpCodes.Ldloc_S, index);
   ilgen.Emit(OpCodes.Ldc_I4_1);
   ilgen.Emit(OpCodes.Add);
   ilgen.Emit(OpCodes.Stloc_S, index);
   
   ilgen.MarkLabel(enterLoop);
   ilgen.Emit(OpCodes.Ldloc_S, index);
   ilgen.Emit(OpCodes.Ldloc_S, input);
   ilgen.Emit(OpCodes.Ldlen);
   ilgen.Emit(OpCodes.Conv_I4);
   ilgen.Emit(OpCodes.Clt);
   ilgen.Emit(OpCodes.Brtrue_S, loopAgain);
   

   ilgen.MarkLabel(loopAgain)
   
   ilgen.Emit(OpCodes.Ldloc_S, ic)
   ilgen.Emit(OpCodes.Ldloc_S, input)
   ilgen.Emit(OpCodes.Ldloc_S, index)
   ilgen.Emit(OpCodes.Ldelem, TInput)
   ilgen.Emit(OpCodes.Callvirt, mAdd)
   
   ilgen.Emit(OpCodes.Ldloc_S, index)
   ilgen.Emit(OpCodes.Ldc_I4_1)
   ilgen.Emit(OpCodes.Add)
   ilgen.Emit(OpCodes.Stloc_S, index)
   
   ilgen.MarkLabel(enterLoop)
   ilgen.Emit(OpCodes.Ldloc_S, index)
   ilgen.Emit(OpCodes.Ldloc_S, input)
   ilgen.Emit(OpCodes.Ldlen)
   ilgen.Emit(OpCodes.Conv_I4)
   ilgen.Emit(OpCodes.Clt)
   ilgen.Emit(OpCodes.Brtrue_S, loopAgain)
   

7. Émettez du code pour effectuer un push de l’objet TOutput dans la pile et obtenir un retour de la méthode. Les variables retVal locales et ic les deux contiennent des références au nouveau TOutput; ic sont utilisées uniquement pour accéder à la ICollection<T>.Add méthode.

   ilgen.Emit(OpCodes.Ldloc_S, retVal);
   ilgen.Emit(OpCodes.Ret);
   

   ilgen.Emit(OpCodes.Ldloc_S, retVal)
   ilgen.Emit(OpCodes.Ret)
   

Appeler la méthode générique

1. Factory est une définition de méthode générique. Pour l’appeler, vous devez affecter des types à ses paramètres de type générique. Utilisez la MakeGenericMethod méthode pour effectuer cette opération. Le code suivant crée une méthode générique construite, en spécifiant StringTInput et List(Of String) (List<string> en C#) pour TOutput, et affiche une représentation sous forme de chaîne de la méthode.

   MethodInfo m = dt.GetMethod("Factory");
   MethodInfo bound =
       m.MakeGenericMethod(typeof(string), typeof(List<string>));
   
   // Display a string representing the bound method.
   Console.WriteLine(bound);
   

   Dim m As MethodInfo = dt.GetMethod("Factory")
   Dim bound As MethodInfo = m.MakeGenericMethod( _
       GetType(String), GetType(List(Of String)))
   
   ' Display a string representing the bound method.
   Console.WriteLine(bound)
   

2. Pour appeler la méthode avec liaison tardive, utilisez la méthode Invoke. Le code suivant crée un tableau de Objectéléments contenant comme seul élément un tableau de chaînes et le transmet en tant que liste d’arguments pour la méthode générique. Le premier paramètre de Invoke est une référence nulle car la méthode est static. La valeur de retour est typée en List(Of String), et son premier élément s’affiche.

   object o = bound.Invoke(null, new object[]{arr});
   List<string> list2 = (List<string>) o;
   
   Console.WriteLine($"The first element is: {list2[0]}");
   

   Dim o As Object = bound.Invoke(Nothing, New Object() {arr})
   Dim list2 As List(Of String) = CType(o, List(Of String))
   
   Console.WriteLine("The first element is: {0}", list2(0))
   

3. Pour appeler la méthode à l’aide d’un délégué, vous devez disposer d’un délégué qui correspond à la signature de la méthode générique construite. Pour ce faire, il est facile de créer un délégué générique. Le code suivant crée une instance du délégué générique D défini dans l’exemple de code, à l’aide de la surcharge de méthode Delegate.CreateDelegate(Type, MethodInfo), et appelle le délégué. Les délégués sont plus performants que les appels à liaison tardive.

   Type dType = typeof(D<string, List <string>>);
   D<string, List <string>> test;
   test = (D<string, List <string>>)
       Delegate.CreateDelegate(dType, bound);
   
   List<string> list3 = test(arr);
   Console.WriteLine($"The first element is: {list3[0]}");
   

   Dim dType As Type = GetType(D(Of String, List(Of String)))
   Dim test As D(Of String, List(Of String))
   test = CType( _
       [Delegate].CreateDelegate(dType, bound), _
       D(Of String, List(Of String)))
   
   Dim list3 As List(Of String) = test(arr)
   Console.WriteLine("The first element is: {0}", list3(0))
   

4. La méthode émise peut également être appelée à partir d’un programme qui fait référence à l’assembly enregistré.

Exemple :

L’exemple de code suivant crée un type non générique, DemoTypeavec une méthode générique. Factory Cette méthode a deux paramètres de type générique, TInput pour spécifier un type d’entrée et TOutput pour spécifier un type de sortie. Le TOutput paramètre de type est contraint d’implémenter ICollection<TInput> (ICollection(Of TInput) en Visual Basic), d’être un type de référence et d’avoir un constructeur sans paramètre.

La méthode a un paramètre formel, qui est un tableau de TInput. La méthode retourne une instance de TOutput ce qui contient tous les éléments du tableau d’entrée. TOutput peut être n’importe quel type de collection générique qui implémente l’interface ICollection<T> générique.

Lorsque le code est exécuté, l’assembly dynamique est enregistré en tant que DemoGenericMethod1.dllet peut être examiné à l’aide du Ildasm.exe (désassembleur IL).

Remarque

Une bonne façon d’apprendre à émettre du code consiste à écrire un programme qui effectue la tâche que vous essayez d’émettre, et à utiliser le désassembleur pour examiner le code CIL produit par le compilateur.

L’exemple de code inclut le code source équivalent à la méthode émise. La méthode émise est appelée avec liaison tardive, et également à l’aide d’un délégué générique déclaré dans l’exemple de code.

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Reflection.Emit;

// Declare a generic delegate that can be used to execute the
// finished method.
//
public delegate TOut D<TIn, TOut>(TIn[] input);

class GenericMethodBuilder
{
    // This method shows how to declare, in Visual Basic, the generic
    // method this program emits. The method has two type parameters,
    // TInput and TOutput, the second of which must be a reference type
    // (class), must have a parameterless constructor (new()), and must
    // implement ICollection<TInput>. This interface constraint
    // ensures that ICollection<TInput>.Add can be used to add
    // elements to the TOutput object the method creates. The method
    // has one formal parameter, input, which is an array of TInput.
    // The elements of this array are copied to the new TOutput.
    //
    public static TOutput Factory<TInput, TOutput>(TInput[] tarray)
        where TOutput : class, ICollection<TInput>, new()
    {
        TOutput ret = new TOutput();
        ICollection<TInput> ic = ret;

        foreach (TInput t in tarray)
        {
            ic.Add(t);
        }
        return ret;
    }

    public static void Main()
    {
        // The following shows the usage syntax of the C#
        // version of the generic method emitted by this program.
        // Note that the generic parameters must be specified
        // explicitly, because the compiler does not have enough
        // context to infer the type of TOutput. In this case, TOutput
        // is a generic List containing strings.
        //
        string[] arr = {"a", "b", "c", "d", "e"};
        List<string> list1 =
            GenericMethodBuilder.Factory<string, List <string>>(arr);
        Console.WriteLine($"The first element is: {list1[0]}");

        // Creating a dynamic assembly requires an AssemblyName
        // object, and the current application domain.
        //
        AssemblyName asmName = new AssemblyName("DemoMethodBuilder1");
        AppDomain domain = AppDomain.CurrentDomain;
        AssemblyBuilder demoAssembly =
            domain.DefineDynamicAssembly(asmName,
                AssemblyBuilderAccess.RunAndSave);

        // Define the module that contains the code. For an
        // assembly with one module, the module name is the
        // assembly name plus a file extension.
        ModuleBuilder demoModule =
            demoAssembly.DefineDynamicModule(asmName.Name,
                asmName.Name+".dll");

        // Define a type to contain the method.
        TypeBuilder demoType =
            demoModule.DefineType("DemoType", TypeAttributes.Public);

        // Define a public static method with standard calling
        // conventions. Do not specify the parameter types or the
        // return type, because type parameters will be used for
        // those types, and the type parameters have not been
        // defined yet.
        //
        MethodBuilder factory =
            demoType.DefineMethod("Factory",
                MethodAttributes.Public | MethodAttributes.Static);

        // Defining generic type parameters for the method makes it a
        // generic method. To make the code easier to read, each
        // type parameter is copied to a variable of the same name.
        //
        string[] typeParameterNames = {"TInput", "TOutput"};
        GenericTypeParameterBuilder[] typeParameters =
            factory.DefineGenericParameters(typeParameterNames);

        GenericTypeParameterBuilder TInput = typeParameters[0];
        GenericTypeParameterBuilder TOutput = typeParameters[1];

        // Add special constraints.
        // The type parameter TOutput is constrained to be a reference
        // type, and to have a parameterless constructor. This ensures
        // that the Factory method can create the collection type.
        //
        TOutput.SetGenericParameterAttributes(
            GenericParameterAttributes.ReferenceTypeConstraint |
            GenericParameterAttributes.DefaultConstructorConstraint);

        // Add interface and base type constraints.
        // The type parameter TOutput is constrained to types that
        // implement the ICollection<T> interface, to ensure that
        // they have an Add method that can be used to add elements.
        //
        // To create the constraint, first use MakeGenericType to bind
        // the type parameter TInput to the ICollection<T> interface,
        // returning the type ICollection<TInput>, then pass
        // the newly created type to the SetInterfaceConstraints
        // method. The constraints must be passed as an array, even if
        // there is only one interface.
        //
        Type icoll = typeof(ICollection<>);
        Type icollOfTInput = icoll.MakeGenericType(TInput);
        Type[] constraints = {icollOfTInput};
        TOutput.SetInterfaceConstraints(constraints);

        // Set parameter types for the method. The method takes
        // one parameter, an array of type TInput.
        Type[] parms = {TInput.MakeArrayType()};
        factory.SetParameters(parms);

        // Set the return type for the method. The return type is
        // the generic type parameter TOutput.
        factory.SetReturnType(TOutput);

        // Generate a code body for the method.
        // -----------------------------------
        // Get a code generator and declare local variables and
        // labels. Save the input array to a local variable.
        //
        ILGenerator ilgen = factory.GetILGenerator();

        LocalBuilder retVal = ilgen.DeclareLocal(TOutput);
        LocalBuilder ic = ilgen.DeclareLocal(icollOfTInput);
        LocalBuilder input = ilgen.DeclareLocal(TInput.MakeArrayType());
        LocalBuilder index = ilgen.DeclareLocal(typeof(int));

        Label enterLoop = ilgen.DefineLabel();
        Label loopAgain = ilgen.DefineLabel();

        ilgen.Emit(OpCodes.Ldarg_0);
        ilgen.Emit(OpCodes.Stloc_S, input);

        // Create an instance of TOutput, using the generic method
        // overload of the Activator.CreateInstance method.
        // Using this overload requires the specified type to have
        // a parameterless constructor, which is the reason for adding
        // that constraint to TOutput. Create the constructed generic
        // method by passing TOutput to MakeGenericMethod. After
        // emitting code to call the method, emit code to store the
        // new TOutput in a local variable.
        //
        MethodInfo createInst =
            typeof(Activator).GetMethod("CreateInstance", Type.EmptyTypes);
        MethodInfo createInstOfTOutput =
            createInst.MakeGenericMethod(TOutput);

        ilgen.Emit(OpCodes.Call, createInstOfTOutput);
        ilgen.Emit(OpCodes.Stloc_S, retVal);

        // Load the reference to the TOutput object, cast it to
        // ICollection<TInput>, and save it.
        //
        ilgen.Emit(OpCodes.Ldloc_S, retVal);
        ilgen.Emit(OpCodes.Box, TOutput);
        ilgen.Emit(OpCodes.Castclass, icollOfTInput);
        ilgen.Emit(OpCodes.Stloc_S, ic);

        // Loop through the array, adding each element to the new
        // instance of TOutput. Note that in order to get a MethodInfo
        // for ICollection<TInput>.Add, it is necessary to first
        // get the Add method for the generic type defintion,
        // ICollection<T>.Add. This is because it is not possible
        // to call GetMethod on icollOfTInput. The static overload of
        // TypeBuilder.GetMethod produces the correct MethodInfo for
        // the constructed type.
        //
        MethodInfo mAddPrep = icoll.GetMethod("Add");
        MethodInfo mAdd = TypeBuilder.GetMethod(icollOfTInput, mAddPrep);

        // Initialize the count and enter the loop.
        ilgen.Emit(OpCodes.Ldc_I4_0);
        ilgen.Emit(OpCodes.Stloc_S, index);
        ilgen.Emit(OpCodes.Br_S, enterLoop);

        // Mark the beginning of the loop. Push the ICollection
        // reference on the stack, so it will be in position for the
        // call to Add. Then push the array and the index on the
        // stack, get the array element, and call Add (represented
        // by the MethodInfo mAdd) to add it to the collection.
        //
        // The other ten instructions just increment the index
        // and test for the end of the loop. Note the MarkLabel
        // method, which sets the point in the code where the
        // loop is entered. (See the earlier Br_S to enterLoop.)
        //
        ilgen.MarkLabel(loopAgain);

        ilgen.Emit(OpCodes.Ldloc_S, ic);
        ilgen.Emit(OpCodes.Ldloc_S, input);
        ilgen.Emit(OpCodes.Ldloc_S, index);
        ilgen.Emit(OpCodes.Ldelem, TInput);
        ilgen.Emit(OpCodes.Callvirt, mAdd);

        ilgen.Emit(OpCodes.Ldloc_S, index);
        ilgen.Emit(OpCodes.Ldc_I4_1);
        ilgen.Emit(OpCodes.Add);
        ilgen.Emit(OpCodes.Stloc_S, index);

        ilgen.MarkLabel(enterLoop);
        ilgen.Emit(OpCodes.Ldloc_S, index);
        ilgen.Emit(OpCodes.Ldloc_S, input);
        ilgen.Emit(OpCodes.Ldlen);
        ilgen.Emit(OpCodes.Conv_I4);
        ilgen.Emit(OpCodes.Clt);
        ilgen.Emit(OpCodes.Brtrue_S, loopAgain);

        ilgen.Emit(OpCodes.Ldloc_S, retVal);
        ilgen.Emit(OpCodes.Ret);

        // Complete the type.
        Type dt = demoType.CreateType();
        // Save the assembly, so it can be examined with Ildasm.exe.
        demoAssembly.Save(asmName.Name+".dll");

        // To create a constructed generic method that can be
        // executed, first call the GetMethod method on the completed
        // type to get the generic method definition. Call MakeGenericType
        // on the generic method definition to obtain the constructed
        // method, passing in the type arguments. In this case, the
        // constructed method has string for TInput and List<string>
        // for TOutput.
        //
        MethodInfo m = dt.GetMethod("Factory");
        MethodInfo bound =
            m.MakeGenericMethod(typeof(string), typeof(List<string>));

        // Display a string representing the bound method.
        Console.WriteLine(bound);

        // Once the generic method is constructed,
        // you can invoke it and pass in an array of objects
        // representing the arguments. In this case, there is only
        // one element in that array, the argument 'arr'.
        //
        object o = bound.Invoke(null, new object[]{arr});
        List<string> list2 = (List<string>) o;

        Console.WriteLine($"The first element is: {list2[0]}");

        // You can get better performance from multiple calls if
        // you bind the constructed method to a delegate. The
        // following code uses the generic delegate D defined
        // earlier.
        //
        Type dType = typeof(D<string, List <string>>);
        D<string, List <string>> test;
        test = (D<string, List <string>>)
            Delegate.CreateDelegate(dType, bound);

        List<string> list3 = test(arr);
        Console.WriteLine($"The first element is: {list3[0]}");
    }
}

/* This code example produces the following output:

The first element is: a
System.Collections.Generic.List`1[System.String] Factory[String,List`1](System.String[])
The first element is: a
The first element is: a
 */

Imports System.Collections.Generic
Imports System.Reflection
Imports System.Reflection.Emit

' Declare a generic delegate that can be used to execute the 
' finished method.
'
Delegate Function D(Of TIn, TOut)(ByVal input() As TIn) As TOut

Class GenericMethodBuilder

    ' This method shows how to declare, in Visual Basic, the generic
    ' method this program emits. The method has two type parameters,
    ' TInput and TOutput, the second of which must be a reference type
    ' (Class), must have a parameterless constructor (New), and must
    ' implement ICollection(Of TInput). This interface constraint
    ' ensures that ICollection(Of TInput).Add can be used to add
    ' elements to the TOutput object the method creates. The method 
    ' has one formal parameter, input, which is an array of TInput. 
    ' The elements of this array are copied to the new TOutput.
    '
    Public Shared Function Factory(Of TInput, _
        TOutput As {ICollection(Of TInput), Class, New}) _
        (ByVal input() As TInput) As TOutput

        Dim retval As New TOutput()
        Dim ic As ICollection(Of TInput) = retval

        For Each t As TInput In input
            ic.Add(t)
        Next

        Return retval
    End Function


    Public Shared Sub Main()
        ' The following shows the usage syntax of the Visual Basic
        ' version of the generic method emitted by this program.
        ' Note that the generic parameters must be specified 
        ' explicitly, because the compiler does not have enough 
        ' context to infer the type of TOutput. In this case, TOutput
        ' is a generic List containing strings.
        ' 
        Dim arr() As String = {"a", "b", "c", "d", "e"}
        Dim list1 As List(Of String) = _
            GenericMethodBuilder.Factory(Of String, List(Of String))(arr)
        Console.WriteLine("The first element is: {0}", list1(0))


        ' Creating a dynamic assembly requires an AssemblyName
        ' object, and the current application domain.
        '
        Dim asmName As New AssemblyName("DemoMethodBuilder1")
        Dim domain As AppDomain = AppDomain.CurrentDomain
        Dim demoAssembly As AssemblyBuilder = _
            domain.DefineDynamicAssembly(asmName, _
                AssemblyBuilderAccess.RunAndSave)

        ' Define the module that contains the code. For an 
        ' assembly with one module, the module name is the 
        ' assembly name plus a file extension.
        Dim demoModule As ModuleBuilder = _
            demoAssembly.DefineDynamicModule( _
                asmName.Name, _
                asmName.Name & ".dll")

        ' Define a type to contain the method.
        Dim demoType As TypeBuilder = demoModule.DefineType( _
            "DemoType", _
            TypeAttributes.Public)

        ' Define a Shared, Public method with standard calling
        ' conventions. Do not specify the parameter types or the
        ' return type, because type parameters will be used for 
        ' those types, and the type parameters have not been
        ' defined yet.
        '
        Dim factory As MethodBuilder = _
            demoType.DefineMethod("Factory", _
                MethodAttributes.Public Or MethodAttributes.Static)

        ' Defining generic type parameters for the method makes it a
        ' generic method. To make the code easier to read, each
        ' type parameter is copied to a variable of the same name.
        '
        Dim typeParameterNames() As String = {"TInput", "TOutput"}
        Dim typeParameters() As GenericTypeParameterBuilder = _
            factory.DefineGenericParameters(typeParameterNames)

        Dim TInput As GenericTypeParameterBuilder = typeParameters(0)
        Dim TOutput As GenericTypeParameterBuilder = typeParameters(1)

        ' Add special constraints.
        ' The type parameter TOutput is constrained to be a reference
        ' type, and to have a parameterless constructor. This ensures
        ' that the Factory method can create the collection type.
        ' 
        TOutput.SetGenericParameterAttributes( _
            GenericParameterAttributes.ReferenceTypeConstraint Or _
            GenericParameterAttributes.DefaultConstructorConstraint)

        ' Add interface and base type constraints.
        ' The type parameter TOutput is constrained to types that
        ' implement the ICollection(Of T) interface, to ensure that
        ' they have an Add method that can be used to add elements.
        '
        ' To create the constraint, first use MakeGenericType to bind 
        ' the type parameter TInput to the ICollection(Of T) interface,
        ' returning the type ICollection(Of TInput), then pass
        ' the newly created type to the SetInterfaceConstraints
        ' method. The constraints must be passed as an array, even if
        ' there is only one interface.
        '
        Dim icoll As Type = GetType(ICollection(Of ))
        Dim icollOfTInput As Type = icoll.MakeGenericType(TInput)
        Dim constraints() As Type = {icollOfTInput}
        TOutput.SetInterfaceConstraints(constraints)

        ' Set parameter types for the method. The method takes
        ' one parameter, an array of type TInput.
        Dim params() As Type = {TInput.MakeArrayType()}
        factory.SetParameters(params)

        ' Set the return type for the method. The return type is
        ' the generic type parameter TOutput.
        factory.SetReturnType(TOutput)

        ' Generate a code body for the method. 
        ' -----------------------------------
        ' Get a code generator and declare local variables and
        ' labels. Save the input array to a local variable.
        '
        Dim ilgen As ILGenerator = factory.GetILGenerator()

        Dim retVal As LocalBuilder = ilgen.DeclareLocal(TOutput)
        Dim ic As LocalBuilder = ilgen.DeclareLocal(icollOfTInput)
        Dim input As LocalBuilder = _
            ilgen.DeclareLocal(TInput.MakeArrayType())
        Dim index As LocalBuilder = _
            ilgen.DeclareLocal(GetType(Integer))

        Dim enterLoop As Label = ilgen.DefineLabel()
        Dim loopAgain As Label = ilgen.DefineLabel()

        ilgen.Emit(OpCodes.Ldarg_0)
        ilgen.Emit(OpCodes.Stloc_S, input)

        ' Create an instance of TOutput, using the generic method 
        ' overload of the Activator.CreateInstance method. 
        ' Using this overload requires the specified type to have
        ' a parameterless constructor, which is the reason for adding 
        ' that constraint to TOutput. Create the constructed generic
        ' method by passing TOutput to MakeGenericMethod. After
        ' emitting code to call the method, emit code to store the
        ' new TOutput in a local variable. 
        '
        Dim createInst As MethodInfo = _
            GetType(Activator).GetMethod("CreateInstance", Type.EmptyTypes)
        Dim createInstOfTOutput As MethodInfo = _
            createInst.MakeGenericMethod(TOutput)

        ilgen.Emit(OpCodes.Call, createInstOfTOutput)
        ilgen.Emit(OpCodes.Stloc_S, retVal)

        ' Load the reference to the TOutput object, cast it to
        ' ICollection(Of TInput), and save it.
        ilgen.Emit(OpCodes.Ldloc_S, retVal)
        ilgen.Emit(OpCodes.Box, TOutput)
        ilgen.Emit(OpCodes.Castclass, icollOfTInput)
        ilgen.Emit(OpCodes.Stloc_S, ic)

        ' Loop through the array, adding each element to the new
        ' instance of TOutput. Note that in order to get a MethodInfo
        ' for ICollection(Of TInput).Add, it is necessary to first 
        ' get the Add method for the generic type defintion,
        ' ICollection(Of T).Add. This is because it is not possible
        ' to call GetMethod on icollOfTInput. The static overload of
        ' TypeBuilder.GetMethod produces the correct MethodInfo for
        ' the constructed type.
        '
        Dim mAddPrep As MethodInfo = icoll.GetMethod("Add")
        Dim mAdd As MethodInfo = _
            TypeBuilder.GetMethod(icollOfTInput, mAddPrep)

        ' Initialize the count and enter the loop.
        ilgen.Emit(OpCodes.Ldc_I4_0)
        ilgen.Emit(OpCodes.Stloc_S, index)
        ilgen.Emit(OpCodes.Br_S, enterLoop)

        ' Mark the beginning of the loop. Push the ICollection
        ' reference on the stack, so it will be in position for the
        ' call to Add. Then push the array and the index on the 
        ' stack, get the array element, and call Add (represented
        ' by the MethodInfo mAdd) to add it to the collection.
        ' 
        ' The other ten instructions just increment the index
        ' and test for the end of the loop. Note the MarkLabel
        ' method, which sets the point in the code where the 
        ' loop is entered. (See the earlier Br_S to enterLoop.)
        '
        ilgen.MarkLabel(loopAgain)

        ilgen.Emit(OpCodes.Ldloc_S, ic)
        ilgen.Emit(OpCodes.Ldloc_S, input)
        ilgen.Emit(OpCodes.Ldloc_S, index)
        ilgen.Emit(OpCodes.Ldelem, TInput)
        ilgen.Emit(OpCodes.Callvirt, mAdd)

        ilgen.Emit(OpCodes.Ldloc_S, index)
        ilgen.Emit(OpCodes.Ldc_I4_1)
        ilgen.Emit(OpCodes.Add)
        ilgen.Emit(OpCodes.Stloc_S, index)

        ilgen.MarkLabel(enterLoop)
        ilgen.Emit(OpCodes.Ldloc_S, index)
        ilgen.Emit(OpCodes.Ldloc_S, input)
        ilgen.Emit(OpCodes.Ldlen)
        ilgen.Emit(OpCodes.Conv_I4)
        ilgen.Emit(OpCodes.Clt)
        ilgen.Emit(OpCodes.Brtrue_S, loopAgain)

        ilgen.Emit(OpCodes.Ldloc_S, retVal)
        ilgen.Emit(OpCodes.Ret)

        ' Complete the type.
        Dim dt As Type = demoType.CreateType()
        ' Save the assembly, so it can be examined with Ildasm.exe.
        demoAssembly.Save(asmName.Name & ".dll")

        ' To create a constructed generic method that can be
        ' executed, first call the GetMethod method on the completed 
        ' type to get the generic method definition. Call MakeGenericType
        ' on the generic method definition to obtain the constructed
        ' method, passing in the type arguments. In this case, the
        ' constructed method has String for TInput and List(Of String)
        ' for TOutput. 
        '
        Dim m As MethodInfo = dt.GetMethod("Factory")
        Dim bound As MethodInfo = m.MakeGenericMethod( _
            GetType(String), GetType(List(Of String)))

        ' Display a string representing the bound method.
        Console.WriteLine(bound)


        ' Once the generic method is constructed, 
        ' you can invoke it and pass in an array of objects 
        ' representing the arguments. In this case, there is only
        ' one element in that array, the argument 'arr'.
        '
        Dim o As Object = bound.Invoke(Nothing, New Object() {arr})
        Dim list2 As List(Of String) = CType(o, List(Of String))

        Console.WriteLine("The first element is: {0}", list2(0))


        ' You can get better performance from multiple calls if
        ' you bind the constructed method to a delegate. The 
        ' following code uses the generic delegate D defined 
        ' earlier.
        '
        Dim dType As Type = GetType(D(Of String, List(Of String)))
        Dim test As D(Of String, List(Of String))
        test = CType( _
            [Delegate].CreateDelegate(dType, bound), _
            D(Of String, List(Of String)))

        Dim list3 As List(Of String) = test(arr)
        Console.WriteLine("The first element is: {0}", list3(0))

    End Sub
End Class

' This code example produces the following output:
'
'The first element is: a
'System.Collections.Generic.List`1[System.String] Factory[String,List`1](System.String[])
'The first element is: a
'The first element is: a

Voir aussi

• MethodBuilder
• Guide pratique pour définir un type générique avec l’émission de réflexion