Exporter (0) Imprimer
Développer tout
Développer Réduire

Type.DeclaringMethod, propriété

Remarque : cette propriété est nouvelle dans le .NET Framework version 2.0.

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.

Espace de noms : System
Assembly : mscorlib (dans mscorlib.dll)

public virtual MethodBase DeclaringMethod { get; }
/** @property */
public MethodBase get_DeclaringMethod ()

public function get DeclaringMethod () : MethodBase

Valeur de la propriété

Si le Type en cours 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, référence Null (Nothing en Visual Basic).

La méthode de déclaration est une définition de méthode générique. Ainsi, si DeclaringMethod ne retourne pas la valeur référence Null (Nothing en Visual Basic), DeclaringMethod.IsGenericMethodDefinition retourne la valeur true.

Les propriétés DeclaringType et DeclaringMethod 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 était défini à l'origine :

  • Si la propriété DeclaringMethod retourne MethodInfo, ce MethodInfo représente une définition de méthode générique et l'objet Type actuel représente un paramètre de type de cette définition de méthode générique.

  • Si la propriété DeclaringMethod retourne référence Null (Nothing en Visual Basic), la propriété DeclaringType retourne toujours un objet Type qui représente une définition de type générique, et l'objet Type actuel représente un paramètre de type de cette définition de type de générique.

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

RemarqueRemarque

Dans le .NET Framework version 2.0, les constructeurs génériques ne sont pas pris en charge.

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

L'exemple de code suivant définit une classe qui possède 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. Lorsqu'il affiche des informations sur les paramètres de type de la définition de méthode générique, dans la méthode DisplayGenericMethodInfo, l'exemple de code affiche la valeur de la propriété DeclaringMethod pour le paramètre de type générique de la méthode.

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 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

.NET Framework

Prise en charge dans : 2.0

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft