(0) exportieren Drucken
Alle erweitern

MethodInfo.MakeGenericMethod-Methode

Ersetzt die Typparameter der aktuellen generischen Methodendefinition durch die Elemente eines Arrays von Typen und gibt ein MethodInfo-Objekt zurück, das die sich ergebende konstruierte Methode darstellt.

Namespace: System.Reflection
Assembly: mscorlib (in mscorlib.dll)

public virtual MethodInfo MakeGenericMethod (
	params Type[] typeArguments
)
public MethodInfo MakeGenericMethod (
	Type[] typeArguments
)
public function MakeGenericMethod (
	... typeArguments : Type[]
) : MethodInfo
Nicht zutreffend.

Parameter

typeArguments

Ein Array von Typen, die die Typparameter der aktuellen generischen Methodendefinition ersetzen sollen.

Rückgabewert

Ein MethodInfo-Objekt, das die konstruierte Methode darstellt, die durch Ersetzen der Typparameter der aktuellen generischen Methodendefinition durch die Elemente von typeArguments erstellt wurde.

AusnahmetypBedingung

InvalidOperationException

Die aktuelle MethodInfo stellt keine generische Methodendefinition dar. Das heißt, IsGenericMethodDefinition gibt false zurück.

ArgumentNullException

typeArguments ist NULL-Verweis (Nothing in Visual Basic).

- oder -

Eines der Elemente von typeArguments ist NULL-Verweis (Nothing in Visual Basic).

ArgumentException

Die Anzahl von Elementen in typeArguments entspricht nicht der Anzahl von Typparametern in der aktuellen generischen Methodendefinition.

- oder -

Eines der Elemente von typeArguments entspricht nicht den für den entsprechenden Typparameter der aktuellen generischen Methodendefinition angegebenen Einschränkungen.

NotSupportedException

Diese Methode wird nicht unterstützt.

Mit der MakeGenericMethod-Methode können Sie Code verfassen, in dem den Typparametern einer generischen Methodendefinition spezifische Typen zugewiesen werden, um auf diese Weise ein MethodInfo-Objekt zu erstellen, das eine bestimmte konstruierte Methode darstellt. Wenn durch die ContainsGenericParameters-Eigenschaft dieses MethodInfo-Objekts true zurückgegeben wird, können Sie sie verwenden, um die Methode aufzurufen oder um einen Delegaten zu erstellen, der die Methode aufruft.

Methoden, die mit der MakeGenericMethod-Methode konstruiert werden, können offen sein. Das heißt, dass einige ihrer Typargumente Typparameter von einschließenden generischen Typen sein können. Sie können solche offen konstruierten Methoden z. B. verwenden, wenn Sie dynamische Assemblys generieren. Betrachten Sie beispielsweise den folgenden C#-, Visual Basic- und C++-Code.

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

Der Methodentext von M enthält einen Aufruf der Methode N, in dem der Typparameter von M und der Typ Int32 angegeben werden. Mit der IsGenericMethodDefinition-Eigenschaft wird für die N<V,int>-Methode der Wert false zurückgegeben. Mit der ContainsGenericParameters-Eigenschaft wird true zurückgegeben. Daher kann die Methode N<V,int> nicht aufgerufen werden.

Eine Liste der unveränderlichen Bedingungen für spezifische Begriffe zu generischen Methoden finden Sie unter der IsGenericMethod-Eigenschaft. Eine Liste der unveränderlichen Bedingungen für andere Begriffe, die in generischer Reflektion verwendet werden, finden Sie unter der IsGenericType-Eigenschaft.

Im folgenden Codebeispiel werden die Eigenschaften und Methoden von MethodInfo veranschaulicht, die die Überprüfung generischer Methoden unterstützen. Im Beispiel wird Folgendes ausgeführt:

  • Definiert eine Klasse, die über eine generische Methode verfügt.

  • Erstellt eine MethodInfo, die die generische Methode darstellt.

  • Zeigt Eigenschaften der generischen Methodendefinition an.

  • Weist den Typparametern von MethodInfo Typargumente zu und ruft die sich ergebende konstruierte generische Methode auf.

  • Zeigt Eigenschaften der konstruierten generischen Methode an.

  • Ruft die generische Methodendefinition aus der konstruierten Methode ab und vergleicht diese mit der ursprünglichen Definition.

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

 */

Windows 98, Windows Server 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

Microsoft .NET Framework 3.0 wird unter Windows Vista, Microsoft Windows XP SP2 und Windows Server 2003 SP1 unterstützt.

.NET Framework

Unterstützt in: 3.0, 2.0

.NET Compact Framework

Unterstützt in: 2.0

XNA Framework

Unterstützt in: 1.0
Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2014 Microsoft