MethodBuilder.DefineGenericParameters(String[]) Yöntem

Tanım

Ad Alanı:

System.Reflection.Emit

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Reflection.Emit.dll

Kaynak:

MethodBuilder.cs

Geçerli yöntem için genel tür parametrelerinin sayısını ayarlar, adlarını belirtir ve kısıtlamalarını tanımlamak için kullanılabilecek bir nesne dizisi GenericTypeParameterBuilder döndürür.

C#

public System.Reflection.Emit.GenericTypeParameterBuilder[] DefineGenericParameters(params string[] names);

Parametreler

names

String[]

Genel tür parametrelerinin adlarını temsil eden dize dizisi.

Döndürülenler

GenericTypeParameterBuilder[]

Genel yöntemin GenericTypeParameterBuilder tür parametrelerini temsil eden bir nesne dizisi.

Özel durumlar

InvalidOperationException

Bu yöntem için genel tür parametreleri zaten tanımlanmıştır.

-veya-

Yöntemi zaten tamamlandı.

-veya-

geçerli SetImplementationFlags(MethodImplAttributes) yöntem için yöntemi çağrıldı.

ArgumentNullException

names, null değeridir.

-veya-

öğesinin names öğesidir null.

ArgumentException

names boş bir dizidir.

Örnekler

Aşağıdaki kod örneği, DemoTypedinamik genel yöntemini DemoMethodiçeren bir dinamik tür oluşturur. Bu yöntemin biri parametre, diğeri de dönüş türü olarak kullanılan iki genel tür parametresi vardır.

Kod yürütürken dinamik derleme DemoGenericMethod1.dll olarak kaydedilir ve Ildasm.exe (IL Ayrıştırıcı) kullanılarak incelenebilir.

Not

Bu kod örneği yalnızca null başvuru döndüren basit bir yöntem gövdesi oluşturur. Genel türler oluşturan ve kullanan daha tam olarak geliştirilmiş bir yöntem gövdesine sahip bir kod örneği için bkz . Nasıl yapılır: Yansıma Yayma ile Genel Yöntem Tanımlama.

C#

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

class DemoMethodBuilder
{

    public static void Main()
    {
        // Creating a dynamic assembly requires an AssemblyName
        // object, and the current application domain.
        //
        AssemblyName asmName =
            new AssemblyName("DemoMethodBuilder1");
        AppDomain domain = AppDomain.CurrentDomain;
        AssemblyBuilder demoAssembly =
            domain.DefineDynamicAssembly(
                asmName,
                AssemblyBuilderAccess.RunAndSave
            );

        // Define the module that contains the code. For an
        // assembly with one module, the module name is the
        // assembly name plus a file extension.
        ModuleBuilder demoModule =
            demoAssembly.DefineDynamicModule(
                asmName.Name,
                asmName.Name + ".dll"
            );

        TypeBuilder demoType = demoModule.DefineType(
            "DemoType",
            TypeAttributes.Public | TypeAttributes.Abstract
        );

        // Define a Shared, Public method with standard calling
        // conventions. Do not specify the parameter types or the
        // return type, because type parameters will be used for
        // those types, and the type parameters have not been
        // defined yet.
        MethodBuilder demoMethod = demoType.DefineMethod(
            "DemoMethod",
            MethodAttributes.Public | MethodAttributes.Static
        );

        // Defining generic parameters for the method makes it a
        // generic method. By convention, type parameters are
        // single alphabetic characters. T and U are used here.
        //
        string[] typeParamNames = {"T", "U"};
        GenericTypeParameterBuilder[] typeParameters =
            demoMethod.DefineGenericParameters(typeParamNames);

        // The second type parameter is constrained to be a
        // reference type.
        typeParameters[1].SetGenericParameterAttributes(
            GenericParameterAttributes.ReferenceTypeConstraint);

        // Use the IsGenericMethod property to find out if a
        // dynamic method is generic, and IsGenericMethodDefinition
        // to find out if it defines a generic method.
        Console.WriteLine("Is DemoMethod generic? {0}",
            demoMethod.IsGenericMethod);
        Console.WriteLine("Is DemoMethod a generic method definition? {0}",
            demoMethod.IsGenericMethodDefinition);

        // Set parameter types for the method. The method takes
        // one parameter, and its type is specified by the first
        // type parameter, T.
        Type[] parms = {typeParameters[0]};
        demoMethod.SetParameters(parms);

        // Set the return type for the method. The return type is
        // specified by the second type parameter, U.
        demoMethod.SetReturnType(typeParameters[1]);

        // Generate a code body for the method. The method doesn't
        // do anything except return null.
        //
        ILGenerator ilgen = demoMethod.GetILGenerator();
        ilgen.Emit(OpCodes.Ldnull);
        ilgen.Emit(OpCodes.Ret);

        // Complete the type.
        Type dt = demoType.CreateType();

        // To bind types to a dynamic generic method, you must
        // first call the GetMethod method on the completed type.
        // You can then define an array of types, and bind them
        // to the method.
        MethodInfo m = dt.GetMethod("DemoMethod");
        Type[] typeArgs = {typeof(string), typeof(DemoMethodBuilder)};
        MethodInfo bound = m.MakeGenericMethod(typeArgs);
        // Display a string representing the bound method.
        Console.WriteLine(bound);

        // Save the assembly, so it can be examined with Ildasm.exe.
        demoAssembly.Save(asmName.Name + ".dll");
    }
}

/* This code example produces the following output:
Is DemoMethod generic? True
Is DemoMethod a generic method definition? True
DemoMethodBuilder DemoMethod[String,DemoMethodBuilder](System.String)
*/

Açıklamalar

yönteminin çağrılması DefineGenericParameters geçerli yöntemi genel hale getirir. Bu değişikliği geri almanın hiçbir yolu yoktur. Bu yöntemin ikinci kez çağrılması bir InvalidOperationExceptionneden olur.

Genel yöntemin tür parametreleri daha sonra yöntemi kullanılarak GetGenericArguments alınabilir.

Kurala göre, tür parametresi adı tek bir büyük harftir.

Daha fazla bilgi için MethodBase.IsGenericMethod ve MethodInfo.GetGenericMethodDefinition bölümlerine bakın. Genel türler hakkında bilgi için bkz Type.IsGenericType. .

Şunlara uygulanır

Ayrıca bkz.

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