Type.DeclaringMethod Proprietà

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Assembly:

netstandard.dll

Assembly:

mscorlib.dll

Ottiene una classe MethodBase che rappresenta il metodo dichiarante se la classe Type corrente rappresenta un parametro di tipo di un metodo generico.

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

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

Valore della proprietà

MethodBase

Se l'oggetto Type corrente rappresenta un parametro di tipo di un metodo generico, una classe MethodBase che rappresenta il metodo dichiarante; in caso contrario, null.

Esempio

Nell'esempio di codice seguente viene definita una classe con un metodo generico, viene assegnato un argomento di tipo al metodo e viene richiamato il metodo generico costruito risultante. Visualizza anche informazioni sulla definizione del metodo generico e sul metodo costruito. Quando si visualizzano informazioni sui parametri di tipo della definizione di metodo generico, nel metodo il codice di esempio mostra il valore della proprietà per il parametro di DisplayGenericMethodInfo DeclaringMethod tipo generico del metodo.

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

 */

Commenti

Il metodo dichiarante è una definizione di metodo generico. In altri, se DeclaringMethod non restituisce , restituisce null DeclaringMethod.IsGenericMethodDefinition true .

Le proprietà e identificano la definizione di tipo generico o la definizione di metodo generico in cui è stato originariamente definito il parametro di DeclaringType DeclaringMethod tipo generico:

• Se la proprietà restituisce un oggetto , che rappresenta una definizione di metodo generico e l'oggetto corrente rappresenta un parametro DeclaringMethod di tipo di tale definizione di metodo MethodInfo MethodInfo Type generico.

• Se la proprietà restituisce , la proprietà restituisce sempre un oggetto che rappresenta una definizione di tipo generico e l'oggetto corrente rappresenta un parametro di tipo DeclaringMethod di tale definizione di tipo null DeclaringType Type Type generico.

• Il recupero DeclaringMethod della proprietà su un tipo la cui proprietà è genera IsGenericParameter false un'eccezione InvalidOperationException .

L'oggetto restituito dalla proprietà è un nel caso di un metodo generico o un MethodBase nel caso di un costruttore DeclaringMethod MethodInfo ConstructorInfo generico.

Nota

Nella versione .NET Framework 2.0, i costruttori generici non sono supportati.

Per un elenco delle condizioni invariabili relative ai termini usati dal processo di reflection generico, vedere i commenti sulla proprietà IsGenericType.

Si applica a

Vedi anche

• IsGenericParameter
• Reflection e tipi generici
• Procedura: esaminare e creare istanze di tipi generici tramite reflection