MethodBuilder.MakeGenericMethod(Type[]) Yöntem

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

System.Reflection.Emit.dll

Paket:

System.Reflection.Emit v4.7.0

Belirtilen genel tür bağımsız değişkenlerini kullanarak geçerli genel yöntem tanımından yapılan genel bir yöntemi döndürür.

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

Parametreler

typeArguments

Type[]

Genel yöntem için tür bağımsız değişkenlerini temsil eden bir nesne dizisi Type .

Döndürülenler

MethodInfo

MethodInfo Belirtilen genel tür bağımsız değişkenleri kullanılarak geçerli genel yöntem tanımından yapılan genel yöntemi temsil eden.

Örnekler

Aşağıdaki kod örneği, tamamlanmamış bir türdeki tamamlanmamış genel yöntem tanımından oluşturulan bir yöntem oluşturur.

Örnek, tek bir türe sahip geçici bir derleme ve modül oluşturur, bir yöntemi Mekler ve yöntemini kullanarak DefineGenericParameters T tür parametresi ekleyerek yöntemi genel hale getirir. type parametresi, yöntemin parametresinin türü ve aynı zamanda dönüş türü olarak kullanılır. Genel yöntem tanımına gövde verilmez ve kapsayan tür tamamlanmaz. Daha MakeGenericMethod sonra yöntemi, (Visual Basic'te)M(Of String) yapılan yöntemi M<String> yapmak için kullanılır. yöntemi tarafından döndürülen alt sınıfı MethodInfo parametreleri üzerinde yansımaya izin vermediğinden örnek kodun MakeGenericMethod çıkışı yoktur.

Not

kullanan MakeGenericMethodbaşka bir kod örneği için bkz DefineGenericParameters. . MakeGenericMethod , genel türler kullanan kod yayarken de yaygın olarak kullanılır. Bkz . Nasıl yapılır: Yansıma Yayma ile Genel Yöntem Tanımlama.

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

Açıklamalar

Dinamik kod yayarken, kapsayan tür tamamlanmadan önce tarafından temsil edilen genel yöntem tanımından oluşan bir MethodBuilderyönteme çağrı yaymanız gerekebilir. Böyle bir şekilde bir yöntemi için oluşturmak MethodInfo için yöntemini kullanabilir MakeGenericMethod ve yayılan çağrıda kullanabilirsinizMethodInfo.

Ayrıca bkz.

• Nasıl yapılır: Yansıma Yayma ile Genel Yöntem Tanımlama