MethodInfo.MakeGenericMethod(Type[]) Metoda

Definicja

Przestrzeń nazw:

System.Reflection

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

MethodInfo.cs

Zastępuje elementy tablicy typów dla parametrów typu bieżącej definicji metody ogólnej i zwraca obiekt reprezentujący wynikową skonstruowaną metodę MethodInfo .

C#

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

Parametry

typeArguments

Type[]

Tablica typów, które mają zostać zastąpione parametrami typu bieżącej definicji metody ogólnej.

Zwraca

MethodInfo

MethodInfo Obiekt reprezentujący skonstruowaną metodę utworzoną przez zastąpienie elementów typeArguments parametrów typu bieżącej definicji metody ogólnej.

Wyjątki

InvalidOperationException

Bieżący MethodInfo element nie reprezentuje definicji metody ogólnej. Oznacza to, IsGenericMethodDefinition że zwraca wartość false.

ArgumentNullException

typeArguments to null.

-lub-

Dowolny element to typeArgumentsnull.

ArgumentException

Liczba elementów w elemencie typeArguments nie jest taka sama jak liczba parametrów typu bieżącej definicji metody ogólnej.

-lub-

Element nie typeArguments spełnia ograniczeń określonych dla odpowiedniego parametru typu bieżącej definicji metody ogólnej.

NotSupportedException

Ta metoda nie jest obsługiwana.

Przykłady

Poniższy przykład kodu przedstawia właściwości i metody MethodInfo , które obsługują badanie metod ogólnych. W przykładzie przedstawiono następujące czynności:

• Definiuje klasę, która ma metodę ogólną.

• Tworzy obiekt MethodInfo reprezentujący metodę ogólną.

• Wyświetla właściwości definicji metody ogólnej.

• Przypisuje argumenty typu do parametrów MethodInfotypu klasy i wywołuje wynikową skonstruowaną metodę ogólną.

• Wyświetla właściwości skonstruowanej metody ogólnej.

• Pobiera definicję metody ogólnej z skonstruowanej metody i porównuje ją z oryginalną definicją.

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

 */

Uwagi

Metoda MakeGenericMethod umożliwia pisanie kodu, który przypisuje określone typy do parametrów typu definicji metody ogólnej, tworząc w ten sposób MethodInfo obiekt reprezentujący konkretną skonstruowaną metodę. ContainsGenericParameters Jeśli właściwość tego MethodInfo obiektu zwraca truewartość , możesz użyć jej do wywołania metody lub utworzenia delegata w celu wywołania metody.

Metody skonstruowane za MakeGenericMethod pomocą metody mogą być otwarte, czyli niektóre z ich argumentów typu mogą być parametrami typu otaczających typy ogólne. Podczas generowania zestawów dynamicznych można użyć takich otwartych metod konstruowanych. Rozważmy na przykład następujący kod C#, Visual Basic i C++.

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);
    }
};

Treść M metody zawiera wywołanie Nmetody , określając parametr M typu i typ Int32. Właściwość IsGenericMethodDefinition zwraca false wartość dla metody N<V,int>. Właściwość ContainsGenericParameters zwraca truemetodę , więc nie można wywołać metody N<V,int> .

Aby uzyskać listę niezmiennych warunków dotyczących warunków specyficznych dla metod ogólnych, zobacz IsGenericMethod właściwość . Aby uzyskać listę niezmiennych warunków dla innych terminów używanych w odbiciu ogólnym, zobacz IsGenericType właściwość .

Dotyczy

Zobacz też

• IsGenericMethodDefinition
• GetGenericMethodDefinition()
• Odbicie i typy ogólne
• Wprowadzenie do typów ogólnych (Przewodnik programowania w języku C#)