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

 

Publicado: octubre de 2016

Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, mediante las restricciones de enlace indicadas.

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

public MethodInfo GetMethod(
	string name,
	BindingFlags bindingAttr,
	Binder binder,
	Type[] types,
	ParameterModifier[] modifiers
)

Parámetros

name
Type: System.String

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

bindingAttr
Type: System.Reflection.BindingFlags

Máscara de bits formada por una o varias enumeraciones BindingFlags que especifican la forma en que se realiza la búsqueda.

o bien

Cero, para devolver null.

binder
Type: System.Reflection.Binder

Objeto que define un conjunto de propiedades y permite realizar operaciones de enlace, que pueden incluir la selección de un método sobrecargado, la coerción de tipos de argumentos y la invocación de un miembro mediante reflexión.

o bien

Referencia nula (Nothing en Visual Basic) para usar la propiedad DefaultBinder.

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.

modifiers
Type: System.Reflection.ParameterModifier[]

Matriz de objetos ParameterModifier que representan los atributos asociados al elemento correspondiente de la matriz types. Solo se ha de usar cuando se llama mediante la interoperabilidad COM y solo se controlan parámetros que se pasan por referencia. El enlazador predeterminado no procesa este parámetro.

Valor devuelto

Type: System.Reflection.MethodInfo

Objeto que representa el método que cumple los requisitos especificados, si se encuentra; en caso contrario, es null.

Exception Condition
AmbiguousMatchException

Se encontró más de un método con el nombre especificado y que coincide con las restricciones de enlace especificadas.

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.

O bien

modifiers es multidimensional.

Aunque el enlazador predeterminado no procesa ParameterModifier (el modifiers parámetro), puede utilizar la abstracta System.Reflection.Binder clase para escribir un enlazador personalizado que procese modifiers. ParameterModifier sólo se utiliza cuando se llama mediante la interoperabilidad COM, y se administran sólo los parámetros que se pasan por referencia.

La siguiente BindingFlags marcas de filtro pueden utilizarse para definir los métodos que desea incluir en la búsqueda:

  • Debe especificar BindingFlags.Instance o BindingFlags.Static para obtener una devolución.

  • Especificar BindingFlags.Public para incluir métodos públicos en la búsqueda.

  • Especificar BindingFlags.NonPublic para incluir métodos no públicos (es decir, métodos privados, internos y protegidos) en la búsqueda.

  • Especificar BindingFlags.FlattenHierarchy para incluir public y protected miembros estáticos en la jerarquía; private no se incluyen los miembros estáticos de las clases heredadas.

La siguiente BindingFlags marcadores modificadores pueden utilizarse para cambiar el funcionamiento de la búsqueda:

  • BindingFlags.IgnoreCase para omitir el caso de name.

  • BindingFlags.DeclaredOnly para buscar sólo los métodos declarados en el Type, no los métodos simplemente heredados.

Vea System.Reflection.BindingFlags para obtener más información.

System_CAPS_noteNota

No se puede omitir los parámetros al buscar constructores y métodos. Sólo se pueden omitir parámetros al invocar.

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

Si la corriente Type representa un parámetro de tipo en la definición de un tipo genérico o un 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

Para métodos genéricos, no incluya los argumentos de tipo en name. Por ejemplo, el código de C# GetMember("MyMethod<int>") busca un miembro con el nombre de texto "MyMethod<int>", en lugar de un método denominado MyMethod que tiene un argumento genérico de tipo int.

En el ejemplo siguiente se busca sobrecargas concretas de MethodA, especificando restricciones de enlace y una gran variedad de tipos de argumento.

System_CAPS_noteNota

El Visual C# 2005 ejemplo 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 j)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        new Type[] { typeof(int), typeof(int) },
        null);
    Console.WriteLine("Found method: {0}", mInfo);

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

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

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

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

  }
}

.NET Framework
Disponible desde 1.1
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Volver al principio
Mostrar: