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, Type[])

 

Recherche la méthode publique spécifiée dont les paramètres correspondent aux types d'arguments spécifiés.

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

public MethodInfo GetMethod(
	string name,
	Type[] types
)

Paramètres

name
Type: System.String

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

types
Type: System.Type[]

Tableau d'objets Type représentant le nombre, l'ordre et le type des paramètres de la méthode à obtenir.

ou

Tableau vide d'objets Type (tels que le champ EmptyTypes les fournit) pour obtenir une méthode qui ne prend aucun paramètre.

Valeur de retour

Type: System.Reflection.MethodInfo

Objet représentant la méthode publique dont les paramètres correspondent aux types d'arguments spécifiés, si elle est trouvée ; sinon, null.

Exception Condition
AmbiguousMatchException

Plusieurs méthodes ont été trouvées avec le nom et les paramètres spécifiés.

ArgumentNullException

name a la valeur null.

ou

types a la valeur null.

ou

Un des éléments de types est null.

ArgumentException

types est multidimensionnel.

La recherche de name respecte la casse. La recherche inclut des méthodes d’instance publique de static et public.

System_CAPS_noteRemarque

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

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

Le name paramètre ne peut pas inclure des arguments de type. Par exemple, le code c# GetMethod("MyGenericMethod<int>") recherche une méthode avec le nom «MyGenericMethod<int>», plutôt que pour une méthode nommée MyGenericMethod qui possède un argument générique de type int. Au lieu de cela, utilisez GetMethod("MyGenericMethod") avec le paramètre approprié dans le types tableau.

L’exemple suivant recherche des surcharges spécifiques de MethodA, en spécifiant une variété de types d’arguments.

System_CAPS_noteRemarque

Le Visual C# 2005 exemple nécessite la /unsafe option du compilateur.


using System;
using System.Reflection;

class Program
{
    // Methods to get:

    public void MethodA(int i, int j) { }

    public void MethodA(int[] i) { }

    public unsafe void MethodA(int* i) { }

    public void MethodA(ref int r) {}

    // Method that takes an out parameter:
    public void MethodA(int i, out int o) { o = 100;}


  static void Main(string[] args)
  {
    MethodInfo mInfo;

    // Get MethodA(int i, int i)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int), typeof(int) });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int[] i)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int[]) });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int* i)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int).MakePointerType() });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(ref int r)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int).MakeByRefType() });
    Console.WriteLine("Found method: {0}", mInfo);

    // Get MethodA(int i, out int o)
    mInfo = typeof(Program).GetMethod("MethodA",
        new Type[] { typeof(int), typeof(int).MakeByRefType() });
    Console.WriteLine("Found method: {0}", mInfo);

  }
}

L’exemple suivant récupère MethodInfo des objets qui représentent les Add méthodes d’un type non générique (le ArrayList classe), un type générique ouvert (le List<T> classe) et un type générique fermé (la List(Of String) type.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get a Type object that represents a non-generic type.
      GetAddMethod(typeof(ArrayList));

      var list = new List<String>();
      // Get a Type object that represents a constructed generic type.
      Type closed = list.GetType();
      GetAddMethod(closed);

      // Get a Type object that represents an open generic type.
      Type open = typeof(List<>);
      GetAddMethod(open);
   }

   private static void GetAddMethod(Type typ)
   {
      MethodInfo method;
      // Determine if this is a generic type.
      if (typ.IsGenericType) {
         // Is it an open generic type?
         if (typ.ContainsGenericParameters)
            method = typ.GetMethod("Add", typ.GetGenericArguments());
         // Get closed generic type arguments.
         else
            method = typ.GetMethod("Add", typ.GenericTypeArguments);
      }
      // This is not a generic type.
      else {
         method = typ.GetMethod("Add", new Type[] { typeof(Object) } );
      }

      // Test if an Add method was found.
      if (method == null) { 
         Console.WriteLine("No Add method found.");
         return;
      }   

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

      Console.WriteLine(")");
   }   
}
// The example displays the following output:
//       System.Collections.ArrayList.Add(Object)
//       System.Collections.Generic.List`1.Add(String)
//       System.Collections.Generic.List`1.Add(T)

The example defines a GetAddMethod method that retrieves the appropriate T:System.Reflection.MethodInfo object. To provide the types argument for an open generic type, it calls the M:System.Type.GetGenericArguments method. To provide the types argument for a closed generic type, it retrieves the value of the P:System.Type.GenericTypeArguments property.

.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: