Partage via


Type.GetMethods Méthode

Définition

Obtient les méthodes du Type actuel.

Surcharges

GetMethods(BindingFlags)

En cas de substitution dans une classe dérivée, recherche les méthodes définies pour le Type actuel, à l'aide des contraintes de liaison spécifiées.

GetMethods()

Retourne toutes les méthodes publiques du Type actuel.

GetMethods(BindingFlags)

Source:
Type.cs
Source:
Type.cs
Source:
Type.cs

En cas de substitution dans une classe dérivée, recherche les méthodes définies pour le Type actuel, à l'aide des contraintes de liaison spécifiées.

public:
 abstract cli::array <System::Reflection::MethodInfo ^> ^ GetMethods(System::Reflection::BindingFlags bindingAttr);
public abstract System.Reflection.MethodInfo[] GetMethods (System.Reflection.BindingFlags bindingAttr);
abstract member GetMethods : System.Reflection.BindingFlags -> System.Reflection.MethodInfo[]
Public MustOverride Function GetMethods (bindingAttr As BindingFlags) As MethodInfo()

Paramètres

bindingAttr
BindingFlags

Combinaison de bits de valeurs d’énumération qui spécifie la façon dont est effectuée la recherche.

- ou -

Default pour retourner un tableau vide.

Retours

Tableau d'objets MethodInfo représentant toutes les méthodes définies pour le Type actuel qui correspondent aux contraintes de liaison spécifiées.

- ou -

Tableau vide du type MethodInfo si aucune méthode n’est définie pour le Type actuel ou si aucune des méthodes définies ne correspond aux contraintes de liaison.

Implémente

Exemples

L’exemple suivant crée une classe avec deux méthodes publiques et une méthode protégée, crée un Type objet correspondant à MyTypeClass, obtient toutes les méthodes publiques et non publiques, et affiche leurs noms.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

// Create a class having two public methods and one protected method.
public ref class MyTypeClass
{
public:
   void MyMethods(){}

   int MyMethods1()
   {
      return 3;
   }


protected:
   String^ MyMethods2()
   {
      return "hello";
   }
};

void DisplayMethodInfo( array<MethodInfo^>^myArrayMethodInfo )
{
   // Display information for all methods.
   for ( int i = 0; i < myArrayMethodInfo->Length; i++ )
   {
      MethodInfo^ myMethodInfo = dynamic_cast<MethodInfo^>(myArrayMethodInfo[ i ]);
      Console::WriteLine( "\nThe name of the method is {0}.", myMethodInfo->Name );
   }
}

int main()
{
   Type^ myType = MyTypeClass::typeid;
   
   // Get the public methods.
   array<MethodInfo^>^myArrayMethodInfo = myType->GetMethods( static_cast<BindingFlags>(BindingFlags::Public | BindingFlags::Instance | BindingFlags::DeclaredOnly) );
   Console::WriteLine( "\nThe number of public methods is {0}->", myArrayMethodInfo->Length );
   
   // Display all the methods.
   DisplayMethodInfo( myArrayMethodInfo );
   
   // Get the nonpublic methods.
   array<MethodInfo^>^myArrayMethodInfo1 = myType->GetMethods( static_cast<BindingFlags>(BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::DeclaredOnly) );
   Console::WriteLine( "\nThe number of protected methods is {0}->", myArrayMethodInfo1->Length );
   
   // Display information for all methods.
   DisplayMethodInfo( myArrayMethodInfo1 );
}
using System;
using System.Reflection;
using System.Reflection.Emit;

// Create a class having two public methods and one protected method.
public class MyTypeClass
{
    public void MyMethods()
    {
    }
    public int MyMethods1()
    {
        return 3;
    }
    protected String MyMethods2()
    {
        return "hello";
    }
}
public class TypeMain
{
    public static void Main()
    {
        Type myType =(typeof(MyTypeClass));
        // Get the public methods.
        MethodInfo[] myArrayMethodInfo = myType.GetMethods(BindingFlags.Public|BindingFlags.Instance|BindingFlags.DeclaredOnly);
        Console.WriteLine("\nThe number of public methods is {0}.", myArrayMethodInfo.Length);
        // Display all the methods.
        DisplayMethodInfo(myArrayMethodInfo);
        // Get the nonpublic methods.
        MethodInfo[] myArrayMethodInfo1 = myType.GetMethods(BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.DeclaredOnly);
        Console.WriteLine("\nThe number of protected methods is {0}.", myArrayMethodInfo1.Length);
        // Display information for all methods.
        DisplayMethodInfo(myArrayMethodInfo1);		
    }
    public static void DisplayMethodInfo(MethodInfo[] myArrayMethodInfo)
    {
        // Display information for all methods.
        for(int i=0;i<myArrayMethodInfo.Length;i++)
        {
            MethodInfo myMethodInfo = (MethodInfo)myArrayMethodInfo[i];
            Console.WriteLine("\nThe name of the method is {0}.", myMethodInfo.Name);
        }
    }
}

Imports System.Reflection
Imports System.Reflection.Emit

' Create a class having two public methods and one protected method.
Public Class MyTypeClass
    Public Sub MyMethods()
    End Sub
    Public Function MyMethods1() As Integer
        Return 3
    End Function 'MyMethods1
    Protected Function MyMethods2() As [String]
        Return "hello"
    End Function 'MyMethods2
End Class
Public Class TypeMain
    Public Shared Sub Main()

        Dim myType As Type = GetType(MyTypeClass)
        ' Get the public methods.
        Dim myArrayMethodInfo As MethodInfo() = myType.GetMethods((BindingFlags.Public Or BindingFlags.Instance Or BindingFlags.DeclaredOnly))
        Console.WriteLine((ControlChars.Cr + "The number of public methods is " & myArrayMethodInfo.Length.ToString() & "."))
        ' Display all the public methods.
        DisplayMethodInfo(myArrayMethodInfo)
        ' Get the nonpublic methods.
        Dim myArrayMethodInfo1 As MethodInfo() = myType.GetMethods((BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.DeclaredOnly))
        Console.WriteLine((ControlChars.Cr + "The number of protected methods is " & myArrayMethodInfo1.Length.ToString() & "."))
        ' Display all the nonpublic methods.
        DisplayMethodInfo(myArrayMethodInfo1)
    End Sub

    Public Shared Sub DisplayMethodInfo(ByVal myArrayMethodInfo() As MethodInfo)
        ' Display information for all methods.
        Dim i As Integer
        For i = 0 To myArrayMethodInfo.Length - 1
            Dim myMethodInfo As MethodInfo = CType(myArrayMethodInfo(i), MethodInfo)
            Console.WriteLine((ControlChars.Cr + "The name of the method is " & myMethodInfo.Name & "."))
        Next i
    End Sub
End Class

Remarques

Pour que la GetMethods(BindingFlags) surcharge récupère correctement les informations de méthode, l’argument bindingAttr doit inclure au moins l’un des BindingFlags.Instance et , BindingFlags.Staticainsi qu’au moins l’un des BindingFlags.NonPublic et BindingFlags.Public.

Les indicateurs de filtre suivants BindingFlags peuvent être utilisés pour définir les méthodes à inclure dans la recherche :

  • Spécifiez BindingFlags.Instance pour inclure les méthodes d’instance.

  • Spécifiez BindingFlags.Static pour inclure des méthodes statiques.

  • Spécifiez BindingFlags.Public pour inclure des méthodes publiques dans la recherche.

  • Spécifiez BindingFlags.NonPublic pour inclure des méthodes non publiques (c’est-à-dire des méthodes privées, internes et protégées) dans la recherche. Seules les méthodes protégées et internes sur les classes de base sont retournées ; les méthodes privées sur les classes de base ne sont pas retournées.

  • Spécifiez BindingFlags.FlattenHierarchy pour inclure et protected les public membres statiques dans la hiérarchie ; private les membres statiques dans les classes héritées ne sont pas inclus.

  • Spécifiez BindingFlags.Default seul pour renvoyer un tableau vide MethodInfo .

Les indicateurs de modification suivants BindingFlags peuvent être utilisés pour modifier le fonctionnement de la recherche :

  • BindingFlags.DeclaredOnly pour rechercher uniquement les méthodes déclarées sur , Typeet non les méthodes qui ont été simplement héritées.

Consultez la rubrique System.Reflection.BindingFlags (éventuellement en anglais) pour plus d'informations.

Dans .NET 6 et les versions antérieures, la GetMethods méthode ne retourne pas les méthodes dans un ordre particulier, tel que l’ordre alphabétique ou l’ordre de déclaration. Votre code ne doit pas dépendre de l’ordre dans lequel les méthodes sont retournées, car cet ordre varie. Toutefois, à compter de .NET 7, l’ordre est déterministe en fonction de l’ordre des métadonnées dans l’assembly.

Si le courant Type représente un type générique construit, cette méthode retourne les objets avec les MethodInfo paramètres de type remplacés par les arguments de type appropriés.

Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode recherche les méthodes de la contrainte de classe ou les méthodes de s’il n’existe aucune contrainte de Object classe.

Voir aussi

S’applique à

GetMethods()

Source:
Type.cs
Source:
Type.cs
Source:
Type.cs

Retourne toutes les méthodes publiques du Type actuel.

public:
 cli::array <System::Reflection::MethodInfo ^> ^ GetMethods();
public:
 virtual cli::array <System::Reflection::MethodInfo ^> ^ GetMethods();
public System.Reflection.MethodInfo[] GetMethods ();
member this.GetMethods : unit -> System.Reflection.MethodInfo[]
abstract member GetMethods : unit -> System.Reflection.MethodInfo[]
override this.GetMethods : unit -> System.Reflection.MethodInfo[]
Public Function GetMethods () As MethodInfo()

Retours

Tableau d'objets MethodInfo représentant toutes les méthodes publiques définies pour le Type actuel.

- ou -

Tableau vide du type MethodInfo si aucune méthode publique n'est définie pour le Type actuel.

Implémente

Remarques

Dans .NET 6 et les versions antérieures, la GetMethods méthode ne retourne pas les méthodes dans un ordre particulier, tel que l’ordre alphabétique ou l’ordre de déclaration. Votre code ne doit pas dépendre de l’ordre dans lequel les méthodes sont retournées, car cet ordre varie. Toutefois, à compter de .NET 7, l’ordre est déterministe en fonction de l’ordre des métadonnées dans l’assembly.

Les constructeurs ne sont pas inclus dans le tableau de méthodes retournées par cet appel. Effectuez un appel distinct à GetConstructors() pour obtenir les méthodes du constructeur.

Le tableau suivant montre quels membres d’une classe de base sont retournés par les méthodes lors de la Get réflexion sur un type.

Type de membre statique Non statique
Constructeur Non Non
Champ Non Oui. Un champ est toujours masqué par nom et signature.
Événement Non applicable La règle système de type courante est que l’héritage est le même que celui des méthodes qui implémentent la propriété. Reflection traite les propriétés comme masquer par nom et signature. Voir la note 2 ci-dessous.
Méthode Non Oui. Une méthode (virtuelle et non virtuelle) peut être hide-by-name ou hide-by-name-and-signature.
Type imbriqué Non Non
Propriété Non applicable La règle système de type courante est que l’héritage est le même que celui des méthodes qui implémentent la propriété. Reflection traite les propriétés comme masquer par nom et signature. Voir la note 2 ci-dessous.
  1. Masquer par nom et signature prend en compte toutes les parties de la signature, y compris les modificateurs personnalisés, les types de retour, les types de paramètres, les sentinelles et les conventions d’appel non managées. Il s’agit d’une comparaison binaire.

  2. Pour la réflexion, les propriétés et les événements sont masqués par nom-et-signature. Si vous avez une propriété avec un accesseur get et un accesseur set dans la classe de base, mais que la classe dérivée n’a qu’un accesseur get, la propriété de classe dérivée masque la propriété de classe de base et vous ne pourrez pas accéder au setter sur la classe de base.

  3. Les attributs personnalisés ne font pas partie du système de type commun.

Notes

Vous ne pouvez pas omettre des paramètres lors de la recherche de constructeurs et de méthodes. Vous pouvez uniquement omettre des paramètres lors de l’appel.

Si le courant Type représente un type générique construit, cette méthode retourne les objets avec les MethodInfo paramètres de type remplacés par les arguments de type appropriés.

Si le actuel Type représente un paramètre de type dans la définition d’un type générique ou d’une méthode générique, cette méthode recherche les méthodes de la contrainte de classe ou les méthodes de s’il n’existe aucune contrainte de Object classe.

Voir aussi

S’applique à