Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Type.GetMethod (String, Type[])

 

Busca el método público especificado cuyos parámetros coincidan con los tipos de argumentos especificados.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

Parámetros

name
Type: System.String

Cadena que contiene el nombre del método público que se va a obtener.

types
Type: System.Type[]

Matriz de objetos Type que representa el número, el orden y el tipo de parámetros que el método debe obtener.

o bien

Una matriz vacía de objetos Type (proporcionados por el campo EmptyTypes) para obtener un método que no requiera parámetros.

Valor devuelto

Type: System.Reflection.MethodInfo

Objeto que representa el método público cuyos parámetros coinciden con los tipos de argumentos especificados, si se encuentra; en caso contrario, null.

Exception Condition
AmbiguousMatchException

Se encuentra más de un método con el nombre y los parámetros especificados.

ArgumentNullException

El valor de name es null.

O bien

El valor de types es null.

O bien

Uno de los elementos de types es null.

ArgumentException

types es multidimensional.

La búsqueda de name distingue mayúsculas de minúsculas. La búsqueda incluye métodos de instancia público static y public.

System_CAPS_noteNota

No se puede omitir los parámetros al buscar constructores y métodos. Solo puede omitir los parámetros al invocar.

Si la actual Type representa un tipo genérico construido, este método devuelve el MethodInfo con los parámetros de tipo sustituidos por los argumentos de tipo adecuado.

Si la actual Type representa un parámetro de tipo en la definición de un tipo o método genérico, este método busca los métodos de la restricción de clase o los métodos de Object si no hay ninguna restricción de clase.

System_CAPS_noteNota

El name parámetro no puede incluir argumentos de tipo. Por ejemplo, el código de C# GetMethod("MyGenericMethod<int>") busca un método con el nombre de texto "MyGenericMethod<int>", en lugar de para un método denominado MyGenericMethod que tiene un argumento genérico de tipo int. En su lugar, use GetMethod("MyGenericMethod") con el parámetro apropiado en el types matriz.

En el ejemplo siguiente se busca sobrecargas concretas de MethodA, especificar una serie de tipos de argumentos.

System_CAPS_noteNota

El Visual C# 2005 en el ejemplo se requiere el /unsafe opción del compilador.


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

  }
}

En el ejemplo siguiente se recuperan MethodInfo objetos que representan el Add métodos de un tipo no genérico (la ArrayList clase), un tipo genérico abierto (la List<T> clase) y un tipo genérico cerrado (el List(Of String) tipo.

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 desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Volver al principio
Mostrar: