Gör så här: Definiera en allmän metod med reflektionsemitta

Den första proceduren visar hur du skapar en enkel generisk metod med två typparametrar och hur du tillämpar klassbegränsningar, gränssnittsbegränsningar och särskilda begränsningar för typparametrarna.

Den andra proceduren visar hur du genererar metodtexten och hur du använder typparametrarna för den generiska metoden för att skapa instanser av generiska typer och anropa deras metoder.

Den tredje proceduren visar hur du anropar den generiska metoden.

Viktigt!

En metod är inte generisk bara för att den tillhör en allmän typ och använder typparametrarna av den typen. En metod är endast generisk om den har en egen typparameterlista. En allmän metod kan visas på en icke-generisk typ, som i det här exemplet. Ett exempel på en icke-generisk metod för en allmän typ finns i Så här definierar du en allmän typ med reflektionsemitta.

Definiera en allmän metod

1. Innan du börjar är det bra att titta på hur den allmänna metoden visas när den skrivs med ett högnivåspråk. Följande kod ingår i exempelkoden för den här artikeln, tillsammans med kod för att anropa den generiska metoden. Metoden har två typparametrar och TInputTOutput, varav den andra måste vara en referenstyp (class), måste ha en parameterlös konstruktor (new) och måste implementera ICollection<TInput>. Den här gränssnittsbegränsningen ICollection<T>.Add säkerställer att metoden kan användas för att lägga till element i samlingen TOutput som metoden skapar. Metoden har en formell parameter, input, som är en matris med TInput. Metoden skapar en samling av typen TOutput och kopierar elementen input i till samlingen.

   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. Definiera en dynamisk sammansättning och en dynamisk modul som ska innehålla den typ som den generiska metoden tillhör. I det här fallet har sammansättningen bara en modul med namnet DemoMethodBuilder1, och modulnamnet är detsamma som sammansättningsnamnet plus ett tillägg. I det här exemplet sparas sammansättningen på disken och körs också, så AssemblyBuilderAccess.RunAndSave anges. Du kan använda Ildasm.exe (IL Disassembler) för att undersöka DemoMethodBuilder1.dll och jämföra den med det gemensamma mellanliggande språket (CIL) för metoden som visas i steg 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. Definiera den typ som den generiska metoden tillhör. Typen behöver inte vara generisk. En generisk metod kan tillhöra antingen en generisk eller icke-generisk typ. I det här exemplet är typen en klass, är inte generisk och heter DemoType.

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

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

4. Definiera den generiska metoden. Om typerna av en generisk metods formella parametrar anges av generiska typparametrar för den generiska metoden använder du DefineMethod(String, MethodAttributes) metodens överbelastning för att definiera metoden. De allmänna typparametrarna för metoden har ännu inte definierats, så du kan inte ange typerna av metodens formella parametrar i anropet till DefineMethod. I det här exemplet heter Factorymetoden . Metoden är offentlig och static (Shared i Visual Basic).

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

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

5. Definiera parametrarna för allmän typ DemoMethod genom att skicka en matris med strängar som innehåller namnen på parametrarna till MethodBuilder.DefineGenericParameters metoden. Detta gör metoden till en allmän metod. Följande kod gör Factory en allmän metod med typparametrar TInput och TOutput. För att göra koden enklare att läsa skapas variabler med dessa namn för att lagra de GenericTypeParameterBuilder objekt som representerar de två typparametrarna.

   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. Du kan också lägga till särskilda begränsningar i typparametrarna. Särskilda begränsningar läggs till med hjälp av SetGenericParameterAttributes metoden . I det här exemplet TOutput är begränsad till att vara en referenstyp och ha en parameterlös konstruktor.

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

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

7. Du kan också lägga till klass- och gränssnittsbegränsningar i typparametrarna. I det här exemplet är typparametern TOutput begränsad till typer som implementerar ICollection(Of TInput) gränssnittet (ICollection<TInput> i C#). Detta säkerställer att Add metoden kan användas för att lägga till element.

   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. Definiera de formella parametrarna för metoden med hjälp av SetParameters metoden. I det här exemplet Factory har metoden en parameter, en matris med TInput. Den här typen skapas genom att anropa MakeArrayType metoden på som GenericTypeParameterBuilder representerar TInput. Argumentet SetParameters för är en matris med Type objekt.

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

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

9. Definiera returtypen för metoden med hjälp av SetReturnType metoden. I det här exemplet returneras en instans av TOutput .

   factory.SetReturnType(TOutput);
   

   factory.SetReturnType(TOutput)
   

10. Generera metodtexten med hjälp av ILGenerator. Mer information finns i den medföljande proceduren för att avge metodtexten.

    Viktigt!

    När du sänder ut anrop till metoder av generiska typer, och typargumenten för dessa typer är typparametrar för den generiska metoden, måste du använda staticGetConstructor(Type, ConstructorInfo)GetMethod(Type, MethodInfo)- och GetField(Type, FieldInfo) -metodöverbelastningarna för TypeBuilder klassen för att hämta konstruerade former av metoderna. Den medföljande proceduren för att avge metodtexten visar detta.

11. Slutför den typ som innehåller metoden och spara sammansättningen. Den medföljande proceduren för att anropa den generiska metoden visar två sätt att anropa den slutförda metoden.

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

Generera metodtexten

1. Hämta en kodgenerator och deklarera lokala variabler och etiketter. Metoden DeclareLocal används för att deklarera lokala variabler. Metoden Factory har fyra lokala variabler: retVal för att lagra den nya TOutput som returneras av metoden, ic för att lagra när den är gjuten TOutput till ICollection<TInput>, input för att lagra indatamatrisen med TInput objekt och index iterera genom matrisen. Metoden har också två etiketter, en för att ange loopen (enterLoop) och en för toppen av loopen (loopAgain), som definieras med hjälp av DefineLabel metoden.

   Det första metoden gör är att läsa in argumentet med opcode Ldarg_0 och lagra det i den lokala variabeln input med 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. Generera kod för att skapa en instans av , med hjälp av TOutputden generiska metodens överlagring av Activator.CreateInstance metoden. Om du använder den här överlagringen måste den angivna typen ha en parameterlös konstruktor, vilket är orsaken till att du lägger till den begränsningen i TOutput. Skapa den konstruerade generiska metoden genom att skicka TOutput till MakeGenericMethod. När du har genererat kod för att anropa metoden genererar du kod för att lagra den i den lokala variabeln retVal med hjälp av 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. Generera kod för att skicka det nya TOutput objektet till ICollection(Of TInput) och lagra det i den lokala variabeln 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. Hämta en MethodInfo som representerar ICollection<T>.Add metoden. Metoden fungerar på en ICollection<TInput>, så det är nödvändigt att hämta metoden som är specifik för den Add konstruerade typen. Du kan inte använda GetMethod metoden för att hämta detta MethodInfo direkt från icollOfTInput, eftersom GetMethod det inte stöds för en typ som har konstruerats med en GenericTypeParameterBuilder. Anropa GetMethodicolli stället , som innehåller den generiska typdefinitionen för det ICollection<T> generiska gränssnittet. Använd GetMethod(Type, MethodInfo)static sedan metoden för att skapa MethodInfo för den konstruerade typen. Följande kod visar detta.

   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. Generera kod för att initiera variabeln index genom att läsa in ett 32-bitars heltal 0 och lagra den i variabeln. Skicka kod för att förgrena till etiketten enterLoop. Den här etiketten har ännu inte markerats eftersom den finns i loopen. Koden för loopen genereras i nästa steg.

   // 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. Generera kod för loopen. Det första steget är att markera toppen av loopen genom att anropa MarkLabel med loopAgain etiketten. Greninstruktioner som använder etiketten förgrenas nu till den här punkten i koden. Nästa steg är att push-överföra TOutput objektet, casta till , till ICollection(Of TInput)stacken. Det behövs inte omedelbart, men måste vara i position för att anropa Add metoden. Därefter skickas indatamatrisen till stacken och sedan variabeln index som innehåller det aktuella indexet i matrisen. Opcode Ldelem dyker upp indexet och matrisen från stacken och push-överför det indexerade matriselementet till stacken. Stacken är nu redo för anropet ICollection<T>.Add till metoden, som visar samlingen och det nya elementet utanför stacken och lägger till elementet i samlingen.

   Resten av koden i loopen ökar indexet och testar för att se om loopen är klar: Indexet och ett 32-bitars heltal 1 överförs till stacken och läggs till, vilket lämnar summan på stacken. summan lagras i index. MarkLabel anropas för att ange den här punkten som startpunkt för loopen. Indexet läses in igen. Indatamatrisen pushas på stacken och Ldlen genereras för att hämta dess längd. Indexet och längden finns nu på stacken och Clt genereras för att jämföra dem. Om indexet är mindre än längden förgrenar Brtrue_S du tillbaka till början av loopen.

   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. Generera kod för att skicka TOutput objektet till stacken och returnera från metoden. De lokala variablerna retVal och ic båda innehåller referenser till den nya TOutput; ic används endast för att komma åt ICollection<T>.Add metoden.

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

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

Anropa den generiska metoden

1. Factory är en allmän metoddefinition. För att kunna anropa den måste du tilldela typer till dess generiska typparametrar. Använd metoden MakeGenericMethod för att göra detta. Följande kod skapar en konstruerad allmän metod som anger String för TInput och List(Of String) (List<string> i C#) för TOutputoch visar en strängrepresentation av metoden.

   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. Om du vill anropa metoden sent bunden använder du Invoke metoden. Följande kod skapar en matris med Object, som innehåller som det enda elementet en matris med strängar, och skickar den som argumentlista för den generiska metoden. Den första parametern Invoke i är en null-referens eftersom metoden är static. Returvärdet gjuts till List(Of String)och dess första element visas.

   object o = bound.Invoke(null, new object[]{arr});
   List<string> list2 = (List<string>) o;
   
   Console.WriteLine("The first element is: {0}", 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. Om du vill anropa metoden med hjälp av ett ombud måste du ha ett ombud som matchar signaturen för den konstruerade generiska metoden. Ett enkelt sätt att göra detta är att skapa ett allmänt ombud. Följande kod skapar en instans av det generiska ombudet D som definierats i exempelkoden med hjälp av Delegate.CreateDelegate(Type, MethodInfo) metodens överlagring och anropar ombudet. Ombud utför bättre än sena anrop.

   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: {0}", 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. Den utgivna metoden kan också anropas från ett program som refererar till den sparade sammansättningen.

Exempel

I följande kodexempel skapas en icke-generisk typ, , DemoTypemed en allmän metod, Factory. Den här metoden har två allmänna typparametrar för TInput att ange en indatatyp och TOutput ange en utdatatyp. Typparametern TOutput är begränsad till att implementera ICollection<TInput> (ICollection(Of TInput) i Visual Basic), vara en referenstyp och ha en parameterlös konstruktor.

Metoden har en formell parameter, som är en matris med TInput. Metoden returnerar en instans av TOutput som innehåller alla element i indatamatrisen. TOutput kan vara vilken generisk samlingstyp som helst som implementerar det ICollection<T> allmänna gränssnittet.

När koden körs sparas den dynamiska sammansättningen som DemoGenericMethod1.dll och kan undersökas med hjälp av Ildasm.exe (IL Disassembler).

Kommentar

Ett bra sätt att lära sig att generera kod är att skriva ett program som utför den uppgift som du försöker generera och använda demonteringen för att undersöka CIL som produceras av kompilatorn.

Kodexemplet innehåller källkod som motsvarar den utgivna metoden. Den utgivna metoden anropas sent bunden och även med hjälp av ett allmänt ombud som deklareras i kodexemplet.

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: {0}", 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: {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.
        //
        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: {0}", 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

Se även

• MethodBuilder
• Gör så här: Definiera en allmän typ med reflektionsemitta