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

 

Publicado: octubre de 2016

Busca el método especificado cuyos parámetros coincidan con los tipos y modificadores de argumentos especificados, usando las restricciones de enlace indicadas y la convención de llamada especificada.

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

public MethodInfo GetMethod(
	string name,
	BindingFlags bindingAttr,
	Binder binder,
	CallingConventions callConvention,
	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.

callConvention
Type: System.Reflection.CallingConventions

Objeto que especifica el conjunto de reglas que van a usarse en cuanto al orden y diseño de los argumentos, la forma de pasar el valor devuelto, los registros que se usan para los argumentos y la forma en que se limpia la pila.

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 (la modifiers parámetro), puede utilizar la abstracta System.Reflection.Binder clase para escribir un enlazador personalizado que procesan modifiers. ParameterModifiersolo se utiliza cuando se llama mediante la interoperabilidad COM, y se administran sólo los parámetros que se pasan por referencia.

La siguiente tabla muestra qué miembros de una clase base se devuelven los GetXXX métodos cuando se reflejan en un tipo.

Tipo de miembro

Estático

No estáticos

Constructor

No

No

Campo

No

Sí. Un campo siempre es ocultar por nombre y firma.

Evento

No es aplicable

La regla de sistema de tipo común es que la herencia es igual que la de los métodos que implementa la propiedad. La reflexión trata las propiedades como ocultar por nombre y firma. Véase la nota 2.

Método

No

Sí. Un método (virtual y no virtuales) pueden ocultar por nombre u ocultar por nombre y firma.

Tipo anidado

No

No

Propiedad

No es aplicable

La regla de sistema de tipo común es que la herencia es igual que la de los métodos que implementa la propiedad. La reflexión trata las propiedades como ocultar por nombre y firma. Véase la nota 2.

  1. Ocultar por nombre y firma considera que todas las partes de la firma, incluidos los modificadores personalizados, devuelven tipos, tipos de parámetro, centinelas y las convenciones de llamada no administradas. Se trata de una comparación binaria.

  2. Para la reflexión, propiedades y eventos están ocultos por nombre y firma. Si tiene una propiedad con una operación get y un descriptor de acceso de la clase base, pero la clase derivada tiene solo un descriptor de acceso get, la propiedad de clase derivada oculta la propiedad de clase base y no podrá tener acceso el establecedor de la clase base.

  3. Atributos personalizados no forman parte del sistema de tipos comunes.

El 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 con el fin de obtener un valor devuelto.

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

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

El siguiente BindingFlags marcas de modificador se pueden utilizar para cambiar el funcionamiento de la búsqueda:

  • BindingFlags.IgnoreCasepara omitir la grafía de name.

  • BindingFlags.DeclaredOnlypara buscar sólo los métodos declarados en el Type, no los métodos que simplemente se han heredado.

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. Solo puede omitir los 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 de tipo adecuado.

Si la corriente 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

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 para un método denominado MyMethod que tiene un argumento genérico de tipo int.

En el ejemplo siguiente se busca sobrecargas concretas de MethodA, especificar las restricciones de enlace, convenciones de llamada y una variedad 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 j)
    mInfo = typeof(Program).GetMethod("MethodA",
        BindingFlags.Public | BindingFlags.Instance,
        null,
        CallingConventions.Any,
        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,
        CallingConventions.Any,
        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,
        CallingConventions.Any,
        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,
        CallingConventions.Any,
        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,
        CallingConventions.Any,
        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: