Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Type.GetMethod méthode (String, BindingFlags)

 

Recherche la méthode spécifiée, à l'aide des contraintes de liaison spécifiées.

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

public MethodInfo GetMethod(
	string name,
	BindingFlags bindingAttr
)

Paramètres

name
Type: System.String

Chaîne contenant le nom de la méthode à obtenir.

bindingAttr
Type: System.Reflection.BindingFlags

Masque de bits constitué d'un ou de plusieurs BindingFlags spécifiant le mode d'exécution de la recherche.

ou

Zéro, pour retourner null.

Valeur de retour

Type: System.Reflection.MethodInfo

Objet qui représente la méthode correspondant aux critères spécifiés, si elle est trouvée ; sinon, null.

Exception Condition
AmbiguousMatchException

Au moins deux méthodes portent le nom spécifié et correspondent aux contraintes de liaison spécifiées.

ArgumentNullException

name a la valeur null.

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

Les éléments suivants BindingFlags les indicateurs de modificateur peuvent être utilisés pour modifier le fonctionnement de la recherche :

Pour plus d'informations, consultez System.Reflection.BindingFlags.

Si une méthode est surchargée et plusieurs surcharges aux contraintes spécifiées par le bindingAttr argument, la méthode lève un AmbiguousMatchException exception. Dans l’exemple suivant, une exception est levée, car :

  • Le TestClass type possède deux surcharges d’instance publique de la DisplayValue (méthode), DisplayValue(String) et DisplayValue(String, Object[]).

  • Le TestClass type possède deux surcharges d’instance publique de la Equals méthode, un d’eux est hérité de Object: Equals(TestClass) et Equals(Object).

using System;
using System.Reflection;

public class TestClass
{
   public void DisplayValue(String s)
   {
      Console.WriteLine(s);
   }

   public void DisplayValue(String s, params Object[] values)
   {
      Console.WriteLine(s, values);
   }

   public static bool Equals(TestClass t1, TestClass t2)
   {
      return Object.ReferenceEquals(t1, t2);
   }

   public bool Equals(TestClass t) 
   {
      return Object.ReferenceEquals(this, t);
   }          
}

public class Example
{
   public static void Main()
   {
      Type t = typeof(TestClass);

      RetrieveMethod(t, "DisplayValue", BindingFlags.Public | BindingFlags.Instance);

      RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Instance);

      RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);

      RetrieveMethod(t, "Equals", BindingFlags.Public | BindingFlags.Static);
   }

   private static void RetrieveMethod(Type t, String name, BindingFlags flags)
   {
      try {
         MethodInfo m = t.GetMethod(name, flags);
         if (m != null) {
            Console.Write("{0}.{1}(", t.Name, m.Name);
            ParameterInfo[] parms= m.GetParameters();
            for (int ctr = 0; ctr <parms.Length; ctr++) {
               Console.Write(parms[ctr].ParameterType.Name);
               if (ctr < parms.Length - 1) 
                  Console.Write(", ");

            }
            Console.WriteLine(")");
         }
         else {
            Console.WriteLine("Method not found");
         }
      }
      catch (AmbiguousMatchException) {
         Console.WriteLine("The following duplicate matches were found:");
         MethodInfo[] methods = t.GetMethods(flags);
         foreach (var method in methods) {
            if (method.Name != name) continue;

            Console.Write("   {0}.{1}(", t.Name, method.Name);
            ParameterInfo[] parms = method.GetParameters();
            for (int ctr = 0; ctr < parms.Length; ctr++) {
               Console.Write(parms[ctr].ParameterType.Name);
               if (ctr < parms.Length - 1) 
                  Console.Write(", ");

            }
            Console.WriteLine(")");
         } 
      }         
      Console.WriteLine();
   }
}
// The example displays the following output:
//       The following duplicate matches were found:
//          TestClass.DisplayValue(String)
//          TestClass.DisplayValue(String, Object[])
//       
//       The following duplicate matches were found:
//          TestClass.Equals(TestClass)
//          TestClass.Equals(Object)
//       
//       TestClass.Equals(TestClass)
//       
//       TestClass.Equals(TestClass, TestClass)

Vous pouvez effectuer l’une des opérations suivantes pour récupérer une méthode spécifique :

  • Modifiez les contraintes de liaison. Dans l’exemple précédent, tente de récupérer une instance publique Equals récupère de la méthode qui est déclarée par le type et pas héritée correctement Equals(TestClass).

  • Appelez une surcharge de la GetMethod méthode inclut un types paramètre qui définit les types de paramètres de la méthode.

  • Appelez le GetMethods(BindingFlags) méthode pour récupérer un tableau qui contient toutes les méthodes appartenant à un type dont les attributs de liaison spécifiées. Vous pouvez ensuite itérer pour identifier les méthodes dupliquées nommés name. Cette approche est illustrée dans le Gestionnaire de l’exemple précédent pour le AmbiguousMatchException exception.

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

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

System_CAPS_noteRemarque

Pour les méthodes génériques, n’incluez pas les arguments de type dans name. Par exemple, le code c# GetMember("MyMethod<int>") recherche un membre portant le nom «MyMethod<int>», plutôt que pour une méthode nommée MyMethod qui possède un argument générique de type int.

L’exemple suivant obtient la méthode correspondant aux indicateurs de liaison spécifiés.


using System;
using System.Reflection;

class Program
{

    // Method to get:
    public void MethodA() { }


    static void Main(string[] args)
    {

        // Get MethodA()
        MethodInfo mInfo = typeof(Program).GetMethod("MethodA",
            BindingFlags.Public | BindingFlags.Instance);
        Console.WriteLine("Found method: {0}", mInfo);

    }
}

.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Retour au début
Afficher: