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

 

Sucht die angegebene öffentliche Methode, deren Parameter den angegebenen Argumenttypen entsprechen.

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

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

Parameter

name
Type: System.String

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

types
Type: System.Type[]

Ein Array von Type-Objekten, das die Anzahl, die Reihenfolge und den Typ der Parameter der abzurufenden Methode darstellt.

- oder -

Ein leeres Array von Type-Objekten (bereitgestellt vom EmptyTypes-Feld) zum Abrufen einer Methode, die keine Parameter akzeptiert.

Rückgabewert

Type: System.Reflection.MethodInfo

Ein Objekt, das die öffentliche Methode darstellt, deren Parameter den angegebenen Argumenttypen entsprechen, sofern gefunden, andernfalls null.

Exception Condition
AmbiguousMatchException

Es wurden mehrere Methoden mit dem angegebenen Namen und den angegebenen Parametern gefunden.

ArgumentNullException

name ist null.

- oder -

types ist null.

- oder -

Eines der Elemente in types ist null.

ArgumentException

types ist mehrdimensional.

Die Suche nach name Groß-/Kleinschreibung beachtet. Die Suche enthält öffentliche statisch und öffentlich Instanzmethoden.

System_CAPS_noteHinweis

Sie können keine Parameter auslassen, beim Nachschlagen von Konstruktoren und Methoden. Sie können nur Parameter auslassen, aufrufen.

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

Die name Parameter kann keine Typargumente enthalten. Z. B. den C#-Code GetMethod("MyGenericMethod<int>") sucht eine Methode mit dem Textnamen "MyGenericMethod<int>", anstatt für eine Methode namens MyGenericMethod , die ein generisches Argument des Typs hat int. Verwenden Sie stattdessen GetMethod("MyGenericMethod") mit dem entsprechenden Parameter in der types Array.

Das folgende Beispiel sucht nach bestimmten Überladungen der MethodA, eine Vielzahl von Argumenttypen angeben.

System_CAPS_noteHinweis

Die Visual C# 2005 Beispiel benötigen Sie die /unsafe -Compileroption.


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);

  }
}

Das folgende Beispiel ruft MethodInfo Objekte, die darstellen, die Add Methoden eines nicht generischen Typs (die ArrayList Klasse), ein offener generischer Typ (die List<T> Klasse), und einen geschlossenen generischen Typs (die List(Of String) Typ.

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