MethodBuilder.MakeGenericMethod(Type[]) Methode

Definition

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Gibt eine aus der aktuellen generischen Methodendefinition mit den angegebenen generischen Typargumenten konstruierte generische Methode zurück.

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

Parameter

typeArguments

Type[]

Ein Array von Type-Objekten, die die Typargumente für die generische Methode darstellen.

Gibt zurück

MethodInfo

Ein MethodInfo, das die aus der aktuellen generischen Methodendefinition mit den angegebenen generischen Typargumenten konstruierte generische Methode darstellt.

Beispiele

Im folgenden Codebeispiel wird eine konstruierte Methode aus einer unvollständigen generischen Methodendefinition in einem unvollständigen Typ erstellt.

Im Beispiel werden eine vorübergehende Assembly und ein Modul mit einem einzelnen Typ erstellt, eine Methode hinzugefügt und die Methode generisch, indem der Typparameter T mithilfe der M -Methode hinzugefügt DefineGenericParameters wird. Der Typparameter wird als Typ des -Parameters der Methode und auch als Rückgabetyp verwendet. Die generische Methodendefinition erhält keinen Text, und der umschließende Typ ist nicht abgeschlossen. Die MakeGenericMethod -Methode wird dann verwendet, um die konstruierte Methode M<String> ( in M(Of String) Visual Basic). Der Beispielcode hat keine Ausgabe, da die von der -Methode zurückgegebene Unterklasse von keine Reflektion MethodInfo MakeGenericMethod über ihre Parameter zulasst.

Hinweis

Ein weiteres Codebeispiel, das MakeGenericMethod verwendet, finden Sie unter DefineGenericParameters . MakeGenericMethod wird auch häufig verwendet, wenn Code ausgegeben wird, der generische Typen verwendet. Weitere Informationen finden Sie unter Vorgehensweise: Definieren einer generischen Methode mit Reflektions-Emit.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void main()
{
    // Define a transient dynamic assembly (only to run, not
    // to save) with one module and a type "Test".
    // 
    AssemblyName^ aName = gcnew 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);
    array<GenericTypeParameterBuilder^>^ typeParams = 
        meb->DefineGenericParameters(gcnew array<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(String::typeid);
    // Note that this is actually a subclass of MethodInfo, 
    // which has rather limited capabilities -- for
    // example, you cannot reflect on its parameters.
}

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

Hinweise

Wenn Sie dynamischen Code senden, müssen Sie möglicherweise einen Aufruf einer Methode aus der generischen Methodendefinition, die durch dargestellt wird, erstellen, bevor der umschließende Typ MethodBuilder abgeschlossen wurde. Sie können die -Methode verwenden, um eine für eine solche konstruierte Methode zu erstellen, und im MakeGenericMethod MethodInfo MethodInfo ausgegebenen Aufruf verwenden.

Siehe auch

• Vorgehensweise: Definieren einer generischen Methode mit Reflektionsausgabe