Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Type.GetMethod-Methode: (String, BindingFlags)

 

Sucht die angegebene Methode unter Verwendung der angegebenen Bindungseinschränkungen.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public MethodInfo GetMethod(
	string name,
	BindingFlags bindingAttr
)

Parameter

name
Type: System.String

Die Zeichenfolge, die den Namen der abzurufenden Methode enthält.

bindingAttr
Type: System.Reflection.BindingFlags

Eine Bitmaske aus einem oder mehreren BindingFlags, die angeben, wie die Suche durchgeführt wird.

- oder -

0 (null), damit null zurückgegeben wird.

Rückgabewert

Type: System.Reflection.MethodInfo

Ein Objekt, das die Methode darstellt, die den angegebenen Anforderungen entspricht, sofern diese gefunden wird. Andernfalls null.

Exception Condition
AmbiguousMatchException

Es wurden mehrere Methoden gefunden, die den angegebenen Namen aufweisen und den angegebenen Bindungseinschränkungen entsprechen.

ArgumentNullException

name ist null.

Die folgenden BindingFlags Filterkennzeichnungen genutzt werden, welche Methoden in die Suche einbezogen werden:

Die folgenden BindingFlags Modifiziererflags können verwendet werden, um die ändern, wie die Suche funktioniert:

Weitere Informationen finden Sie unter System.Reflection.BindingFlags.

Wenn eine Methode überladen wird und mehrere Überladungen die Einschränkungen erfüllt, angegeben durch die bindingAttr Argument, löst die Methode eine AmbiguousMatchException Ausnahme. Im folgenden Beispiel wird eine Ausnahme ausgelöst, da:

  • Die TestClass Typ hat zwei öffentliche Instanz Überladungen der DisplayValue Methode DisplayValue(String) und DisplayValue(String, Object[]).

  • Die TestClass Typ hat zwei öffentliche Instanz Überladungen der Equals -Methode, von denen geerbt wird, von Object: Equals(TestClass) und 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)

Sie können eine der folgenden zum Abrufen einer bestimmten Methode vorgehen:

  • Ändern Sie die bindungseinschränkungen. Im vorherigen Beispiel versucht, eine öffentliche Instanz abzurufen Equals Methode, die vom Typ deklariert wird und nicht geerbt wurde erfolgreich abgerufen Equals(TestClass).

  • Rufen Sie eine Überladung von der GetMethod Methode, enthält eine types Parameter, die die Typen der Parameter der Methode definiert.

  • Rufen Sie die GetMethods(BindingFlags) Methode, um ein Array mit allen Methoden, die zu einem Typ gehören, die über die angegebene Bindungsattribute verfügen abzurufen. Sie können dann durchlaufen, es zum Identifizieren von doppelten Methoden mit dem Namen name. Dieser Ansatz wird veranschaulicht, in dem vorherigen Beispiel Handler für das AmbiguousMatchException Ausnahme.

Wenn die aktuelle Type einen konstruierten generischen Typ darstellt, gibt diese Methode die MethodInfo mit Parametern für den durch die entsprechenden Typargumente ersetzt.

Wenn die aktuelle Type stellt ein Typparameter in der Definition eines generischen Typs oder generische Methode, diese Methode sucht, die Methoden der klasseneinschränkung oder die Methoden der Object Wenn ohne klasseneinschränkung ist.

System_CAPS_noteHinweis

Für generische Methoden enthalten nicht die Typargumente in name. Z. B. den C#-Code GetMember("MyMethod<int>") sucht ein Element mit dem Textnamen "MyMethod<int>", anstatt für eine Methode namens MyMethod , die ein generisches Argument des Typs hat int.

Im folgenden Beispiel wird die Methode, die den angegebenen Bindungsflags entspricht.


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
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Zurück zum Anfang
Anzeigen: