Type.DeclaringMethod Propriété

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Obtient un MethodBase représentant la méthode de déclaration, si le Type actuel représente un paramètre de type d’une méthode générique.

public:
 virtual property System::Reflection::MethodBase ^ DeclaringMethod { System::Reflection::MethodBase ^ get(); };

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

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

member this.DeclaringMethod : System.Reflection.MethodBase

Public Overridable ReadOnly Property DeclaringMethod As MethodBase

Valeur de propriété

MethodBase

Si le Type actuel représente un paramètre de type d’une méthode générique, MethodBase qui représente la méthode de déclaration ; sinon, null.

Exemples

L’exemple de code suivant définit une classe qui a une méthode générique, assigne un argument de type à la méthode et appelle la méthode générique construite résultante. Il affiche également des informations sur la définition de méthode générique et la méthode construite. Lorsque vous affichez des informations sur les paramètres de type de la définition de méthode générique, dans la DisplayGenericMethodInfo méthode, l’exemple de code affiche la valeur de la DeclaringMethod propriété pour le paramètre de type générique de la méthode.

using namespace System;
using namespace System::Reflection;

// Define a class with a generic method.
ref class Example
{
public:
    generic<typename T> static void Generic(T toDisplay)
    {
        Console::WriteLine("\r\nHere it is: {0}", toDisplay);
    }
};

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)
    {
        array<Type^>^ typeArguments = mi->GetGenericArguments();

        Console::WriteLine("\tList type arguments ({0}):", 
            typeArguments->Length);

        for each (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);
            }
        }
    }
};

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 = Example::typeid;
    MethodInfo^ mi = ex->GetMethod("Generic");

    DisplayGenericMethodInfo(mi);

    // Assign the int type to the type parameter of the Example 
    // method.
    //
    MethodInfo^ miConstructed = mi->MakeGenericMethod(int::typeid);

    DisplayGenericMethodInfo(miConstructed);

    // Invoke the method.
    array<Object^>^ args = { 42 };
    miConstructed->Invoke((Object^) 0, 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);
};
        
/* 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

 */

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

 */

Imports System.Reflection

' Define a class with a generic method.
Public Class Example
    Public Shared Sub Generic(Of T)(ByVal toDisplay As T)
        Console.WriteLine(vbCrLf & "Here it is: {0}", toDisplay)
    End Sub
End Class

Public Class Test
    Public Shared Sub Main() 
        Console.WriteLine(vbCrLf & "--- Examine a generic method.")
        
        ' Create a Type object representing class Example, and
        ' get a MethodInfo representing the generic method.
        '
        Dim ex As Type = GetType(Example)
        Dim mi As MethodInfo = ex.GetMethod("Generic")
        
        DisplayGenericMethodInfo(mi)
        
        ' Assign the Integer type to the type parameter of the Example 
        ' method.
        '
        Dim arguments() As Type = { GetType(Integer) }
        Dim miConstructed As MethodInfo = mi.MakeGenericMethod(arguments)
        
        DisplayGenericMethodInfo(miConstructed)

        ' Invoke the method.
        Dim args() As Object = { 42 }
        miConstructed.Invoke(Nothing, args)
        
        ' Invoke the method normally.
        Example.Generic(Of Integer)(42)
        
        ' Get the generic type definition from the constructed method,
        ' and show that it's the same as the original definition.
        '
        Dim miDef As MethodInfo = miConstructed.GetGenericMethodDefinition()
        Console.WriteLine(vbCrLf & "The definition is the same: {0}", _
            miDef Is mi)
    End Sub
      
    Private Shared Sub DisplayGenericMethodInfo(ByVal mi As MethodInfo) 
        Console.WriteLine(vbCrLf & mi.ToString())
        
        Console.WriteLine(vbTab _
            & "Is this a generic method definition? {0}", _
            mi.IsGenericMethodDefinition)

        Console.WriteLine(vbTab & "Is it a generic method? {0}", _
            mi.IsGenericMethod)

        Console.WriteLine(vbTab _
            & "Does it have unassigned generic parameters? {0}", _
            mi.ContainsGenericParameters)

        ' If this is a generic method, display its type arguments.
        '
        If mi.IsGenericMethod Then
            Dim typeArguments As Type() = mi.GetGenericArguments()
            
            Console.WriteLine(vbTab & "List type arguments ({0}):", _
                typeArguments.Length)
            
            For Each tParam As Type In typeArguments
                ' IsGenericParameter is true only for generic type
                ' parameters.
                '
                If tParam.IsGenericParameter Then
                    Console.WriteLine(vbTab & vbTab _
                        & "{0}  parameter position: {1}" _
                        & vbCrLf & vbTab & vbTab _
                        & "   declaring method: {2}", _
                        tParam,  _
                        tParam.GenericParameterPosition, _
                        tParam.DeclaringMethod)
                Else
                    Console.WriteLine(vbTab & vbTab & tParam.ToString())
                End If
            Next tParam
        End If
    End Sub 
End Class 

' 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
'

Remarques

La méthode de déclaration est une définition de méthode générique. Autrement dit, si DeclaringMethod ne retourne pas null , DeclaringMethod.IsGenericMethodDefinition retourne true .

Les DeclaringType DeclaringMethod Propriétés et identifient la définition de type générique ou la définition de méthode générique dans laquelle le paramètre de type générique a été initialement défini :

Si la DeclaringMethod propriété retourne un MethodInfo , qui MethodInfo représente une définition de méthode générique, et l' Type objet actuel représente un paramètre de type de cette définition de méthode générique.
Si la DeclaringMethod propriété retourne null , la DeclaringType propriété retourne toujours un Type objet représentant une définition de type générique, et l' Type objet actuel représente un paramètre de type de cette définition de type générique.
Obtention de la DeclaringMethod propriété sur un type dont la IsGenericParameter propriété false lève une exception InvalidOperationException .

Le MethodBase retourné par la DeclaringMethod propriété est soit MethodInfo dans le cas d’une méthode générique, soit ConstructorInfo dans le cas d’un constructeur générique.

Notes

dans la version .NET Framework 2,0, les constructeurs génériques ne sont pas pris en charge.

Pour obtenir la liste des conditions indifférentes pour les termes utilisés dans la réflexion générique, consultez les notes sur la propriété IsGenericType.

S’applique à