MethodBuilder.MakeGenericMethod(Type[]) Yöntem

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kod:

mscorlib.dll

Belirtilen genel tür bağımsız değişkenleri kullanılarak geçerli genel yöntem tanımından yapılan genel bir yöntem 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öntemin Type tür bağımsız değişkenlerini temsil eden bir nesne dizisi.

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 bir.

Ö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öntem Mekler ve yöntemini kullanarak DefineGenericParameters T tür parametresi ekleyerek yöntemini genel hale getirir. tür parametresi, yöntemin parametresinin türü ve ayrıca dönüş türü olarak kullanılır. Genel yöntem tanımına bir gövde verilmez ve kapsayan tür tamamlanmaz. MakeGenericMethod yöntemi daha sonra M<String> (M(Of String) Visual Basic) oluşturmak 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 çıktısı yok.

Note

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 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. Yöntemini kullanarak MakeGenericMethod böyle bir şekilde bir yöntemi oluşturabilir MethodInfo ve yayılan çağrıda öğesini MethodInfo kullanabilirsiniz.

Ayrıca bkz.

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