MethodInfo.MakeGenericMethod(Type[]) Yöntem

Tanım

Ad Alanı:

System.Reflection

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Kaynak:

MethodInfo.cs

Geçerli genel yöntem tanımının tür parametreleri için bir tür dizisinin öğelerinin yerini alır ve sonuçta elde edilen oluşturulur yöntemi temsil eden bir MethodInfo nesne döndürür.

C#

public virtual System.Reflection.MethodInfo MakeGenericMethod(params Type[] typeArguments);

Parametreler

typeArguments

Type[]

Geçerli genel yöntem tanımının tür parametreleriyle değiştirilecek bir tür dizisi.

Döndürülenler

MethodInfo

MethodInfo Geçerli genel yöntem tanımının tür parametreleri için öğelerinin typeArguments yerini alarak oluşturulan yöntemi temsil eden bir nesne.

Özel durumlar

InvalidOperationException

geçerli MethodInfo , genel bir yöntem tanımını temsil etmez. Yani döndürür IsGenericMethodDefinitionfalse.

ArgumentNullException

typeArguments, null değeridir.

-veya-

öğesinden herhangi biri typeArguments şeklindedir null.

ArgumentException

içindeki typeArguments öğelerin sayısı, geçerli genel yöntem tanımının tür parametrelerinin sayısıyla aynı değildir.

-veya-

öğesi typeArguments , geçerli genel yöntem tanımının karşılık gelen tür parametresi için belirtilen kısıtlamaları karşılamıyor.

NotSupportedException

Bu yöntem desteklenmiyor.

Örnekler

Aşağıdaki kod örneği, genel yöntemlerin incelenmesini MethodInfo destekleyen özelliklerini ve yöntemlerini gösterir. Örnek aşağıdakileri yapar:

• Genel bir yöntemi olan bir sınıf tanımlar.

• Genel yöntemi temsil eden bir MethodInfo oluşturur.

• Genel yöntem tanımının özelliklerini görüntüler.

• türü bağımsız değişkenlerini öğesinin MethodInfotür parametrelerine atar ve sonuçta elde edilen genel yöntemi çağırır.

• Yapılandırılan genel yöntemin özelliklerini görüntüler.

• Yapılan yöntemden genel yöntem tanımını alır ve özgün tanımıyla karşılaştırır.

C#

using System;
using System.Reflection;

// Define a class with a generic method.
public class Example
{
    public static void Generic<T>(T toDisplay)
    {
        Console.WriteLine("\r\nHere it is: {0}", toDisplay);
    }
}

public class Test
{
    public static void Main()
    {
        Console.WriteLine("\r\n--- Examine a generic method.");

        // Create a Type object representing class Example, and
        // get a MethodInfo representing the generic method.
        //
        Type ex = typeof(Example);
        MethodInfo mi = ex.GetMethod("Generic");

        DisplayGenericMethodInfo(mi);

        // Assign the int type to the type parameter of the Example
        // method.
        //
        MethodInfo miConstructed = mi.MakeGenericMethod(typeof(int));

        DisplayGenericMethodInfo(miConstructed);

        // Invoke the method.
        object[] args = {42};
        miConstructed.Invoke(null, args);

        // Invoke the method normally.
        Example.Generic<int>(42);

        // Get the generic type definition from the closed method,
        // and show it's the same as the original definition.
        //
        MethodInfo miDef = miConstructed.GetGenericMethodDefinition();
        Console.WriteLine("\r\nThe definition is the same: {0}",
            miDef == mi);
    }

    private static void DisplayGenericMethodInfo(MethodInfo mi)
    {
        Console.WriteLine("\r\n{0}", mi);

        Console.WriteLine("\tIs this a generic method definition? {0}",
            mi.IsGenericMethodDefinition);

        Console.WriteLine("\tIs it a generic method? {0}",
            mi.IsGenericMethod);

        Console.WriteLine("\tDoes it have unassigned generic parameters? {0}",
            mi.ContainsGenericParameters);

        // If this is a generic method, display its type arguments.
        //
        if (mi.IsGenericMethod)
        {
            Type[] typeArguments = mi.GetGenericArguments();

            Console.WriteLine("\tList type arguments ({0}):",
                typeArguments.Length);

            foreach (Type tParam in typeArguments)
            {
                // IsGenericParameter is true only for generic type
                // parameters.
                //
                if (tParam.IsGenericParameter)
                {
                    Console.WriteLine("\t\t{0}  parameter position {1}" +
                        "\n\t\t   declaring method: {2}",
                        tParam,
                        tParam.GenericParameterPosition,
                        tParam.DeclaringMethod);
                }
                else
                {
                    Console.WriteLine("\t\t{0}", tParam);
                }
            }
        }
    }
}

/* This example produces the following output:

--- Examine a generic method.

Void Generic[T](T)
        Is this a generic method definition? True
        Is it a generic method? True
        Does it have unassigned generic parameters? True
        List type arguments (1):
                T  parameter position 0
                   declaring method: Void Generic[T](T)

Void Generic[Int32](Int32)
        Is this a generic method definition? False
        Is it a generic method? True
        Does it have unassigned generic parameters? False
        List type arguments (1):
                System.Int32

Here it is: 42

Here it is: 42

The definition is the same: True

 */

Açıklamalar

yöntemi, MakeGenericMethod genel bir yöntem tanımının tür parametrelerine belirli türler atayan kod yazmanıza olanak tanır, böylece belirli bir oluşturulur yöntemi temsil eden bir MethodInfo nesne oluşturur. Bu MethodInfo nesnenin ContainsGenericParameters özelliği döndürürsetrue, yöntemini çağırmak veya yöntemini çağırmak için bir temsilci oluşturmak için kullanabilirsiniz.

yöntemiyle yapılan yöntemler açık olabilir, diğer bir ifadeyle MakeGenericMethod , tür bağımsız değişkenlerinden bazıları genel türleri kapsayan tür parametreleri olabilir. Dinamik derlemeler oluştururken bu tür açık oluşturulmuş yöntemleri kullanabilirsiniz. Örneğin, aşağıdaki C#, Visual Basic ve C++ kodunu göz önünde bulundurun.

class C
{
    T N<T,U>(T t, U u) {...}
    public V M<V>(V v)
    {
        return N<V,int>(v, 42);
    }
}

Class C
    Public Function N(Of T,U)(ByVal ta As T, ByVal ua As U) As T
        ...
    End Function
    Public Function M(Of V)(ByVal va As V ) As V
        Return N(Of V, Integer)(va, 42)
    End Function
End Class

ref class C
{
private:
    generic <typename T, typename U> T N(T t, U u) {...}
public:
    generic <typename V> V M(V v)
    {
        return N<V, int>(v, 42);
    }
};

yönteminin M yöntem gövdesi, türü parametresini M ve türünü Int32belirten bir yöntemi Nçağrısı içerir. IsGenericMethodDefinition özelliği yöntemi N<V,int>için döndürürfalse. ContainsGenericParameters özelliği döndürürtrue, bu nedenle yöntem N<V,int> çağrılamaz.

Genel yöntemlere özgü koşulların sabit koşullarının listesi için özelliğine IsGenericMethod bakın. Genel yansımada kullanılan diğer terimlere ilişkin sabit koşulların listesi için özelliğine IsGenericType bakın.

Şunlara uygulanır

Ayrıca bkz.

• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• Yansıma ve Genel Türler
• Genel Türlere Giriş (C# Programlama Kılavuzu)