Type.DeclaringMethod Właściwość

Definicja

Przestrzeń nazw:

System

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

Type.cs

Pobiera obiekt MethodBase reprezentujący metodę deklaratowania, jeśli bieżący Type reprezentuje parametr typu metody ogólnej.

C#

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

Wartość właściwości

MethodBase

Jeśli bieżący Type reprezentuje parametr typu metody ogólnej, który MethodBase reprezentuje metodę deklaratowania; w przeciwnym razie null.

Przykłady

Poniższy przykład kodu definiuje klasę, która ma metodę ogólną, przypisuje argument typu do metody i wywołuje wynikową skonstruowaną metodę ogólną. Wyświetla również informacje o definicji metody ogólnej i skonstruowanej metodzie. Podczas wyświetlania informacji o parametrach typu definicji metody ogólnej w DisplayGenericMethodInfo metodzie przykładowy kod pokazuje wartość DeclaringMethod właściwości parametru typu ogólnego metody.

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 deklarowania jest definicją metody ogólnej. Oznacza to, że jeśli DeclaringMethod nie zwraca nullwartości , funkcja DeclaringMethod.IsGenericMethodDefinition zwraca wartość true.

Właściwości DeclaringType i DeclaringMethod identyfikują definicję typu ogólnego lub definicję metody ogólnej, w której pierwotnie zdefiniowano parametr typu ogólnego:

• DeclaringMethod Jeśli właściwość zwraca MethodInfowartość , która MethodInfo reprezentuje definicję metody ogólnej, a bieżący Type obiekt reprezentuje parametr typu tej definicji metody ogólnej.

• DeclaringMethod Jeśli właściwość zwraca nullwartość , DeclaringType właściwość zawsze zwraca obiekt reprezentujący definicję Type typu ogólnego, a bieżący Type obiekt reprezentuje parametr typu tej definicji typu ogólnego.

• DeclaringMethod Pobieranie właściwości typu, którego IsGenericParameter właściwość jest false zgłaszana jako InvalidOperationException.

Wartość MethodBase zwracana przez DeclaringMethod właściwość jest albo MethodInfo elementem w przypadku metody ogólnej, albo ConstructorInfo w przypadku konstruktora ogólnego.

Uwaga

W .NET Framework w wersji 2.0 konstruktory ogólne nie są obsługiwane.

Aby zapoznać się z listą niezmiennych warunków warunków używanych w odbiciu ogólnym, zobacz IsGenericType uwagi dotyczące właściwości.

Dotyczy

Zobacz też

• IsGenericParameter
• Odbicie i typy ogólne
• Instrukcje: Badanie i tworzenie wystąpień typów ogólnych za pomocą odbicia