Procedura: Definire un metodo generico utilizzando il reflection emit

La prima procedura illustra come creare un metodo generico semplice con due parametri di tipo e come applicare vincoli di classe, vincoli di interfaccia e vincoli speciali ai parametri di tipo.

La seconda procedura illustra come generare il corpo del metodo e come usare i parametri di tipo del metodo generico per creare istanze di tipi generici e chiamare i relativi metodi.

La terza procedura illustra come richiamare il metodo generico.

Importante

Un metodo non è generico solo perché appartiene a un tipo generico e usa i parametri di tipo di tale tipo. Un metodo è generico solo se ha un proprio elenco di parametri di tipo. Un metodo generico può essere visualizzato in un tipo non generico, come in questo esempio. Per un esempio di metodo non generico su un tipo generico, vedere Procedura: Definire un tipo generico con Reflection Emit.

Definire un metodo generico

1. Prima di iniziare, è utile esaminare come appare il metodo generico quando viene scritto usando un linguaggio di alto livello. Il codice seguente è incluso nel codice di esempio per questo articolo, insieme al codice per chiamare il metodo generico. Il metodo ha due parametri di tipo, TInput e TOutput, il secondo dei quali deve essere un tipo riferimento (class), deve avere un costruttore senza parametri (new) e deve implementare ICollection<TInput>. Questo vincolo di interfaccia garantisce che il metodo ICollection<T>.Add possa essere utilizzato per aggiungere elementi alla raccolta TOutput creata dal metodo . Il metodo ha un parametro formale, input, che è una matrice di TInput. Il metodo crea una raccolta di tipo TOutput e copia gli elementi di input nella raccolta.

   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. Definire un assembly dinamico e un modulo dinamico per contenere il tipo al quale appartiene il metodo generico. In questo caso, l'assembly ha un solo modulo, denominato DemoMethodBuilder1e il nome del modulo è uguale al nome dell'assembly più un'estensione. In questo esempio l'assembly viene salvato su disco ed eseguito, quindi viene specificato AssemblyBuilderAccess.RunAndSave. È possibile usare il Ildasm.exe (Disassembler IL) per esaminare DemoMethodBuilder1.dll e confrontarlo con il linguaggio intermedio comune (CIL) per il metodo illustrato nel passaggio 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. Definire il tipo a cui appartiene il metodo generico. Il tipo non deve essere generico. Un metodo generico può appartenere a un tipo generico o non generico. In questo esempio il tipo è una classe, non è generico ed è denominato DemoType.

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

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

4. Definire il metodo generico. Se i tipi di parametri formali di un metodo generico vengono specificati dai parametri di tipo generico del metodo generico, utilizzare l'overload del metodo DefineMethod(String, MethodAttributes) per definire il metodo. I parametri di tipo generico del metodo non sono ancora definiti, pertanto non è possibile specificare i tipi dei parametri formali del metodo nella chiamata a DefineMethod. In questo esempio il metodo è denominato Factory. Il metodo è pubblico e static (Shared in Visual Basic).

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

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

5. Definire i parametri di tipo generico di DemoMethod passando una matrice di stringhe contenente i nomi dei parametri al metodo MethodBuilder.DefineGenericParameters. In questo modo il metodo è un metodo generico. Il codice seguente rende Factory un metodo generico con parametri di tipo TInput e TOutput. Per semplificare la lettura del codice, le variabili con questi nomi vengono create per contenere gli oggetti GenericTypeParameterBuilder che rappresentano i due parametri di tipo.

   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. Facoltativamente, aggiungere vincoli speciali ai parametri di tipo. I vincoli speciali vengono aggiunti usando il metodo SetGenericParameterAttributes. In questo esempio TOutput è vincolato a un tipo riferimento e a un costruttore senza parametri.

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

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

7. Facoltativamente, aggiungere vincoli di classe e interfaccia ai parametri di tipo. In questo esempio il parametro di tipo TOutput è vincolato ai tipi che implementano l'interfaccia ICollection(Of TInput) (ICollection<TInput> in C#). In questo modo è possibile usare il metodo Add per aggiungere elementi.

   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. Definire i parametri formali del metodo usando il metodo SetParameters. In questo esempio il metodo Factory ha un parametro, una matrice di TInput. Questo tipo viene creato chiamando il metodo MakeArrayType sul GenericTypeParameterBuilder che rappresenta TInput. L'argomento di SetParameters è una matrice di oggetti Type.

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

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

9. Definire il tipo restituito per il metodo utilizzando il metodo SetReturnType. In questo esempio viene restituita un'istanza di TOutput.

   factory.SetReturnType(TOutput);
   

   factory.SetReturnType(TOutput)
   

10. Generare il corpo del metodo usando ILGenerator. Per informazioni dettagliate, vedere la procedura associata per l'emissione del corpo del metodo.

    Importante

    Quando si effettuano chiamate a metodi di tipi generici e gli argomenti di tipo di tali tipi sono parametri di tipo del metodo generico, è necessario utilizzare gli overload dei metodi staticGetConstructor(Type, ConstructorInfo), GetMethod(Type, MethodInfo)e GetField(Type, FieldInfo) della classe TypeBuilder per ottenere versioni costruite dei metodi. La procedura associata per l'emissione del corpo del metodo dimostra questo.

11. Completare il tipo che contiene il metodo e salvare l'assembly. La procedura associata per richiamare il metodo generico mostra due modi per richiamare il metodo completato.

    // 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")
    

Generare il corpo del metodo

1. Ottenere un generatore di codice e dichiarare variabili e etichette locali. Il metodo DeclareLocal viene usato per dichiarare le variabili locali. Il metodo Factory include quattro variabili locali: retVal per contenere il nuovo TOutput restituito dal metodo , ic contenere il TOutput quando viene eseguito il cast a ICollection<TInput>, input per contenere la matrice di input di oggetti TInput e index per scorrere la matrice. Il metodo include anche due etichette, una per immettere il ciclo (enterLoop) e una per l'inizio del ciclo (loopAgain), definita usando il metodo DefineLabel.

   La prima cosa che il metodo esegue consiste nel caricare il relativo argomento usando Ldarg_0 opcode e archiviarlo nella variabile locale input usando Stloc_S opcode.

   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. Generare codice per creare un'istanza di TOutputusando l'overload generico del metodo Activator.CreateInstance. L'uso di questo overload richiede che il tipo specificato disponga di un costruttore senza parametri, motivo per l'aggiunta di tale vincolo a TOutput. Creare il metodo generico costruito passando TOutput a MakeGenericMethod. Dopo aver creato codice per chiamare il metodo, generare codice per archiviarlo nella variabile locale retVal usando 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. Generare codice per eseguire il cast del nuovo oggetto TOutput per ICollection(Of TInput) e archiviarlo nella variabile locale ic.

   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. Ottiene un MethodInfo che rappresenta il metodo ICollection<T>.Add. Il metodo agisce su un ICollection<TInput>, quindi è necessario ottenere il metodo Add specifico del tipo costruito. Non è possibile utilizzare il metodo GetMethod per ottenere questo MethodInfo direttamente da icollOfTInput, perché GetMethod non è supportato in un tipo costruito con un GenericTypeParameterBuilder. Chiamare invece GetMethod in icoll, che contiene la definizione di tipo generico per l'interfaccia generica ICollection<T>. Usare quindi il metodo GetMethod(Type, MethodInfo)static per produrre il MethodInfo per il tipo costruito. Il codice seguente illustra questa operazione.

   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. Generare codice per inizializzare la variabile index caricando un intero a 32 bit 0 e archiviandolo nella variabile. Generare codice per diramarsi verso l'etichetta enterLoop. Questa etichetta non è ancora stata contrassegnata perché si trova all'interno del ciclo. Il codice per il ciclo viene generato nel passaggio successivo.

   // 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. Generare codice per il ciclo. Il primo passaggio consiste nel contrassegnare la parte superiore del ciclo chiamando MarkLabel con l'etichetta loopAgain. Le istruzioni di ramo che utilizzano l'etichetta ora si dirameranno in questo punto del codice. Il passaggio successivo consiste nello spingere l'oggetto TOutput, convertito in ICollection(Of TInput), sullo stack. Non è necessario immediatamente, ma deve essere in posizione per chiamare il metodo Add. Successivamente, l'array di input viene inserito sullo stack, quindi la variabile index contenente l'indice corrente nell'array. L'opcode Ldelem rimuove l'indice e l'array dallo stack e inserisce l'elemento indicizzato dell'array sullo stack. Lo stack è ora pronto per la chiamata al metodo ICollection<T>.Add, che estrae la raccolta e il nuovo elemento dallo stack e aggiunge l'elemento alla raccolta.

   Il resto del codice nel ciclo incrementa l'indice e verifica se il ciclo è terminato: l'indice e un intero a 32 bit 1 vengono inseriti nello stack e aggiunti, lasciando la somma nello stack; la somma viene archiviata in index. MarkLabel viene chiamato per impostare questo punto come punto di ingresso per il ciclo. L'indice viene caricato di nuovo. La matrice di input viene inserita nello stack e Ldlen viene generata per ottenere la relativa lunghezza. L'indice e la lunghezza sono ora presenti nello stack e Clt viene emesso per confrontarli. Se l'indice è minore della lunghezza, Brtrue_S torna all'inizio del ciclo.

   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. Generare codice per eseguire il push dell'oggetto TOutput nello stack e restituire dal metodo . Le variabili locali retVal e ic contengono entrambi riferimenti al nuovo TOutput; ic viene usato solo per accedere al metodo di ICollection<T>.Add.

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

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

Richiamare il metodo generico

1. Factory è una definizione di metodo generica. Per richiamarlo, è necessario assegnare tipi ai relativi parametri di tipo generico. Usare il metodo MakeGenericMethod per eseguire questa operazione. Il codice seguente crea un metodo generico costruito, specificando String per TInput e List(Of String) (List<string> in C#) per TOutpute visualizza una rappresentazione di stringa del metodo .

   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. Per richiamare il metodo ad associazione tardiva, utilizzare il metodo Invoke. Il codice seguente crea una matrice di Object, contenente come unico elemento una matrice di stringhe e la passa come elenco di argomenti per il metodo generico. Il primo parametro di Invoke è un riferimento Null perché il metodo è static. Il valore restituito viene convertito a List(Of String)e si visualizza il primo elemento.

   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. Per richiamare il metodo usando un delegato, è necessario disporre di un delegato che corrisponda alla firma del metodo generico costruito. Un modo semplice per eseguire questa operazione consiste nel creare un delegato generico. Il codice seguente crea un'istanza del delegato generico D definita nel codice di esempio, usando l'overload del metodo Delegate.CreateDelegate(Type, MethodInfo) e richiama il delegato. I delegati offrono prestazioni migliori rispetto alle chiamate ad associazione tardiva.

   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. Il metodo generato può anche essere chiamato da un programma che fa riferimento all'assembly salvato.

Esempio

Nell'esempio di codice seguente viene creato un tipo non generico, DemoType, con un metodo generico Factory. Questo metodo include due parametri di tipo generico, TInput per specificare un tipo di input e TOutput per specificare un tipo di output. Il parametro di tipo TOutput è vincolato a implementare ICollection<TInput> (ICollection(Of TInput) in Visual Basic), per essere un tipo riferimento e per avere un costruttore senza parametri.

Il metodo ha un parametro formale, ovvero una matrice di TInput. Il metodo restituisce un'istanza di TOutput che contiene tutti gli elementi della matrice di input. TOutput può essere qualsiasi tipo di raccolta generico che implementa l'interfaccia generica ICollection<T>.

Quando viene eseguito il codice, l'assembly dinamico viene salvato come DemoGenericMethod1.dlle può essere esaminato usando il Ildasm.exe (Disassembler IL).

Nota

Un buon modo per imparare a creare codice consiste nel scrivere un programma che esegue l'attività che si sta tentando di generare e usare il disassembler per esaminare l'CIL prodotto dal compilatore.

L'esempio di codice include codice sorgente equivalente al metodo emesso. Il metodo emesso viene richiamato con associazione tardiva e anche usando un delegato generico dichiarato nell'esempio di codice.

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

Vedere anche

• MethodBuilder
• Procedura: Definire un tipo generico con Reflection Emit