MethodBuilder.MakeGenericMethod(Type[]) Metoda

Definice

Obor názvů:

System.Reflection.Emit

Sestavení:

netstandard.dll, System.Reflection.Emit.dll

Vrátí obecnou metodu sestavenou z aktuální definice obecné metody pomocí zadaných argumentů obecného typu.

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

[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
[System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
public override System.Reflection.MethodInfo MakeGenericMethod(params Type[] typeArguments);

[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")>]
[<System.Diagnostics.CodeAnalysis.RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")>]
override this.MakeGenericMethod : Type[] -> System.Reflection.MethodInfo

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

Parametry

typeArguments

Type[]

Pole Type objektů, které představují argumenty typu pro obecnou metodu.

Návraty

MethodInfo

Představuje MethodInfo obecnou metodu sestavenou z aktuální definice obecné metody pomocí zadaných argumentů obecného typu.

Atributy

RequiresDynamicCodeAttribute RequiresUnreferencedCodeAttribute

Příklady

Následující příklad kódu vytvoří konstruovanou metodu z neúplné obecné definice metody v neúplném typu.

Příklad vytvoří přechodné sestavení a modul s jedním typem, přidá metodu a vytvoří metodu Mobecnou přidáním parametru typu T pomocí DefineGenericParameters metody. Parametr typu se používá jako typ parametru metody a také jako jeho návratový typ. Definice obecné metody nemá tělo a nadřazený typ není dokončen. Metoda MakeGenericMethod se pak použije k vytvoření vytvořené metody M<String> (M(Of String) v Visual Basic). Ukázkový kód nemá žádný výstup, protože podtřída vrácená MethodInfo metodou MakeGenericMethod neumožňuje reflexi nad jeho parametry.

Note

Další příklad kódu, který používá MakeGenericMethod, viz DefineGenericParameters. MakeGenericMethod se používá také široce při generování kódu, který používá obecné typy. Viz Postupy: Definování obecné metody pomocí generování reflexe.

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

Poznámky

Při generování dynamického kódu může být nutné vygenerovat volání metody vytvořené z obecné definice metody reprezentované znakem , MethodBuilderpřed dokončením uzavření typu. Tuto metodu MakeGenericMethodMethodInfo můžete použít k vytvoření takové vytvořené metody a použití MethodInfo v generovaném volání.

Viz také

• Postupy: Definování obecné metody pomocí generování reflexe