Type.DeclaringMethod Eigenschaft

Definition

Namespace:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Quelle:

Type.cs

Ruft eine MethodBase ab, die die deklarierende Methode darstellt, wenn der aktuelle Type einen Typparameter einer generischen Methode darstellt.

C#

public virtual System.Reflection.MethodBase? DeclaringMethod { get; }

Eigenschaftswert

MethodBase

Wenn der aktuelle Type einen Typparameter einer generischen Methode darstellt, eine MethodBase, die die deklarierende Methode darstellt, andernfalls null.

Beispiele

Im folgenden Codebeispiel wird eine Klasse definiert, die über eine generische Methode verfügt, der Methode ein Typargument zugewiesen und die resultierende konstruierte generische Methode aufgerufen. Außerdem werden Informationen zur generischen Methodendefinition und zur konstruierten Methode angezeigt. Beim Anzeigen von Informationen zu den Typparametern der generischen Methodendefinition zeigt der Beispielcode in der DisplayGenericMethodInfo -Methode den Wert der DeclaringMethod -Eigenschaft für den generischen Typparameter der Methode an.

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

 */

Hinweise

Die deklarierende Methode ist eine generische Methodendefinition. Das heißt, wenn DeclaringMethod nicht zurückgibt null, wird zurückgegeben DeclaringMethod.IsGenericMethodDefinitiontrue.

Die DeclaringType Eigenschaften und DeclaringMethod geben die generische Typdefinition oder die generische Methodendefinition an, in der der generische Typparameter ursprünglich definiert wurde:

• Wenn die DeclaringMethod -Eigenschaft einen MethodInfozurückgibt, MethodInfo der eine generische Methodendefinition darstellt, und das aktuelle Type Objekt einen Typparameter dieser generischen Methodendefinition darstellt.

• Wenn die DeclaringMethod -Eigenschaft zurückgibtnull, gibt die -Eigenschaft immer ein Type Objekt zurück, das DeclaringType eine generische Typdefinition darstellt, und das aktuelle Type Objekt stellt einen Typparameter dieser generischen Typdefinition dar.

• Beim Abrufen der DeclaringMethod -Eigenschaft für einen Typ, dessen IsGenericParameter -Eigenschaft ausgelöst wird, wird false ein InvalidOperationExceptionausgelöst.

Das MethodBase von der DeclaringMethod -Eigenschaft zurückgegebene ist entweder im MethodInfo Fall einer generischen Methode oder im Fall eines generischen Konstruktors ein .ConstructorInfo

Hinweis

In der .NET Framework Version 2.0 werden generische Konstruktoren nicht unterstützt.

Eine Liste der invarianten Bedingungen für Begriffe, für Begriffe, die für die Reflektion mit generischen Methoden verwendet werden, finden Sie in den Hinweisen zur Eigenschaft IsGenericType.

Gilt für:

Weitere Informationen

• IsGenericParameter
• Reflektion und generische Typen
• How to: Untersuchen und Instanziieren von generischen Typen mit Reflektion