MethodBuilder.MakeGenericMethod(Type[]) Methode

public:
 override System::Reflection::MethodInfo ^ MakeGenericMethod(... cli::array <Type ^> ^ typeArguments);

public override System.Reflection.MethodInfo MakeGenericMethod(params Type[] typeArguments);

override this.MakeGenericMethod : Type[] -> System.Reflection.MethodInfo

Public Overrides Function MakeGenericMethod (ParamArray typeArguments As Type()) As MethodInfo

Parameters

Retouren

Een MethodInfo weergave van de algemene methode die is samengesteld op basis van de huidige algemene methodedefinitie met behulp van de opgegeven algemene typeargumenten.

Voorbeelden

In het volgende codevoorbeeld wordt een samengestelde methode gemaakt op basis van een onvolledige algemene methodedefinitie in een onvolledig type.

Het voorbeeld maakt een tijdelijke assembly en module met één type, voegt een methode Mtoe en maakt de methode algemeen door een typeparameter T toe te voegen met behulp van de DefineGenericParameters methode. De typeparameter wordt gebruikt als het type van de parameter van de methode en ook als retourtype. De algemene methodedefinitie krijgt geen hoofdtekst en het insluittype is niet voltooid. De methode MakeGenericMethod wordt vervolgens gebruikt om de samengestelde methode te maken M<String> (M(Of String) in Visual Basic). De voorbeeldcode heeft geen uitvoer, omdat de subklasse van MethodInfo geretourneerd door de MakeGenericMethod methode geen weerspiegeling van de parameters toestaat.

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

class Example
{
    public static void Main()
    {
        // Define a transient dynamic assembly (only to run, not
        // to save) with one module and a type "Test".
        //
        AssemblyName aName = new AssemblyName("MyDynamic");
        AssemblyBuilder ab =
            AppDomain.CurrentDomain.DefineDynamicAssembly(
                aName,
                AssemblyBuilderAccess.Run);
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name);
        TypeBuilder tb = mb.DefineType("Test");

        // Add a public static method "M" to Test, and make it a
        // generic method with one type parameter named "T").
        //
        MethodBuilder meb = tb.DefineMethod("M",
            MethodAttributes.Public | MethodAttributes.Static);
        GenericTypeParameterBuilder[] typeParams =
            meb.DefineGenericParameters(new string[] { "T" });

        // Give the method one parameter, of type T, and a
        // return type of T.
        meb.SetParameters(typeParams);
        meb.SetReturnType(typeParams[0]);

        // Create a MethodInfo for M<string>, which can be used in
        // emitted code. This is possible even though the method
        // does not yet have a body, and the enclosing type is not
        // created.
        MethodInfo mi = meb.MakeGenericMethod(typeof(string));
        // Note that this is actually a subclass of MethodInfo,
        // which has rather limited capabilities -- for
        // example, you cannot reflect on its parameters.
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

Class Example

    Public Shared Sub Main()
    
        ' Define a transient dynamic assembly (only to run, not
        ' to save) with one module and a type "Test".
        ' 
        Dim aName As AssemblyName = New AssemblyName("MyDynamic")
        Dim ab As AssemblyBuilder = _
            AppDomain.CurrentDomain.DefineDynamicAssembly( _
                aName, _
                AssemblyBuilderAccess.Run)
        Dim mb As ModuleBuilder = ab.DefineDynamicModule(aName.Name)
        Dim tb As TypeBuilder = mb.DefineType("Test")

        ' Add a Public Shared method "M" to Test, and make it a
        ' generic method with one type parameter named "T").
        '
        Dim meb As MethodBuilder = tb.DefineMethod("M", _
            MethodAttributes.Public Or MethodAttributes.Static)
        Dim typeParams() As GenericTypeParameterBuilder = _
            meb.DefineGenericParameters(New String() { "T" })

        ' Give the method one parameter, of type T, and a 
        ' return type of T.
        meb.SetParameters(typeParams)
        meb.SetReturnType(typeParams(0))

        ' Create a MethodInfo for M(Of String), which can be used 
        ' in emitted code. This is possible even though the method
        ' does not yet have a body, and the enclosing type is not
        ' created.
        Dim mi As MethodInfo = _
            meb.MakeGenericMethod(GetType(String))
        ' Note that this is actually a subclass of MethodInfo, 
        ' which has rather limited capabilities -- for
        ' example, you cannot reflect on its parameters.
    End Sub
End Class

Opmerkingen

Wanneer u dynamische code verzendt, moet u mogelijk een aanroep verzenden naar een methode die is samengesteld uit de algemene methodedefinitie die wordt vertegenwoordigd door een MethodBuilder, voordat het insluittype is voltooid. U kunt de MakeGenericMethod methode gebruiken om een MethodInfo dergelijke samengestelde methode te maken en de MethodInfo methode in de verzonden aanroep te gebruiken.

Zie ook

• Procedure: Een algemene methode definiëren met Reflectie Emit