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.InvokeMember (String, BindingFlags, Binder, Object, Object[])

 

Publicado: octubre de 2016

Invoca al miembro especificado, aplica las restricciones de enlace igualmente especificadas y compara la lista de argumentos indicada.

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

public object InvokeMember(
	string name,
	BindingFlags invokeAttr,
	Binder binder,
	object target,
	object[] args
)

Parámetros

name
Type: System.String

Cadena que contiene el nombre del constructor, el método, la propiedad o el miembro de campo al que se va a invocar.

o bien

Cadena vacía ("") para llamar al miembro predeterminado.

-o-

Para los miembros de IDispatch, cadena que representa el identificador DispID, por ejemplo "[DispID=3]".

invokeAttr
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. El acceso puede corresponder a uno de los marcadores BindingFlags, como Public, NonPublic, Private, InvokeMethod, GetField, etc. No es necesario especificar el tipo de búsqueda. Si se omite el tipo de búsqueda, se usan BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static.

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. Observe que la definición explícita de un objeto Binder puede resultar necesaria para llamar correctamente a sobrecargas de método con argumentos variables.

target
Type: System.Object

Objeto donde debe invocarse al miembro especificado.

args
Type: System.Object[]

Matriz que contiene los argumentos que se van a pasar al miembro al cual se va a invocar.

Valor devuelto

Type: System.Object

Objeto que representa el valor devuelto del miembro invocado.

Exception Condition
ArgumentNullException

invokeAttr no contiene CreateInstance y name es null.

ArgumentException

invokeAttr no es un atributo BindingFlags válido.

O bien

invokeAttr no contiene una de las siguientes marcas de enlace: InvokeMethod, CreateInstance, GetField, SetField, GetProperty o SetProperty.

O bien

invokeAttr contiene CreateInstance combinado con InvokeMethod, GetField, SetField, GetProperty o SetProperty.

O bien

invokeAttr contiene tanto GetField como SetField.

O bien

invokeAttr contiene tanto GetProperty como SetProperty.

O bien

invokeAttr contiene InvokeMethod combinado con SetField o SetProperty.

O bien

invokeAttr contiene SetField y args tiene más de un elemento.

O bien

Se llama a este método en un objeto COM pero no se pasa una de las siguientes marcas de enlace: BindingFlags.InvokeMethod, BindingFlags.GetProperty, BindingFlags.SetProperty, BindingFlags.PutDispProperty o BindingFlags.PutRefDispProperty.

O bien

Una de las matrices de parámetros con nombre contiene una cadena que es null.

MethodAccessException

El miembro especificado es un inicializador de clase.

MissingFieldException

No se encuentran el campo o la propiedad.

MissingMethodException

No se encuentra ningún método que coincida con los argumentos en args.

O bien

El objeto Type actual representa un tipo que contiene parámetros de tipo abierto, es decir, ContainsGenericParameters devuelve true.

TargetException

No se puede invocar al miembro especificado en target.

AmbiguousMatchException

Más de un método coincide con los criterios de enlace.

NotSupportedException

.NET Compact Framework no admite actualmente este método.

InvalidOperationException

El método representado por name tiene uno o más parámetros de tipo genérico no especificados. Es decir, la propiedad ContainsGenericParameters del método devuelve true.

System_CAPS_noteNota

No se puede utilizar InvokeMember para invocar un método genérico.

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

  • Especificar BindingFlags.Public para incluir miembros públicos en la búsqueda.

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

  • Especificar BindingFlags.FlattenHierarchy para incluir miembros estáticos en la jerarquía.

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 miembros declarados en el Type, no los miembros que simplemente se han heredado.

La siguiente BindingFlags indicadores de invocación pueden usarse para denotar la acción que se realizará con el miembro:

  • CreateInstance para invocar un constructor. name se omite. No es válido con otros indicadores de invocación.

  • InvokeMethod para invocar un método, pero no un constructor o un inicializador de tipo. No es válido con SetField o SetProperty. Si InvokeMethod se especifica por sí mismo, BindingFlags.Public, BindingFlags.Instance, y BindingFlags.Static se incluyen automáticamente.

  • GetField Para obtener el valor de un campo. No es válido con SetField.

  • SetField Para establecer el valor de un campo. No es válido con GetField.

  • GetProperty Para obtener una propiedad. No es válido con SetProperty.

  • SetProperty Para establecer una propiedad. No es válido con GetProperty.

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

Se invoca un método si se cumplen las condiciones siguientes:

  • El número de parámetros de la declaración del método es igual al número de argumentos de la args matriz (a menos que se definan argumentos predeterminados en el miembro y BindingFlags.OptionalParamBinding se especifica).

  • El tipo de cada argumento se puede convertir por el enlazador al tipo del parámetro.

El enlazador encontrará todos los métodos de coincidencia. Estos métodos se encuentran en función del tipo de enlace solicitado (BindingFlags valores InvokeMethod, GetProperty, y así sucesivamente). El conjunto de métodos se filtra por el nombre, número de argumentos y un conjunto de modificadores de búsqueda definidos en el enlazador.

Una vez seleccionado el método, se invoca. Se comprueba la accesibilidad en ese momento. La búsqueda puede controlar el conjunto de métodos se buscan en función del atributo de accesibilidad asociado al método. El Binder.BindToMethod método de la Binder clase es responsable de seleccionar el método que se va a invocar. El enlazador predeterminado selecciona a la coincidencia más específica.

Se omiten las restricciones de acceso de código de plena confianza; es decir, constructores privados, métodos, campos y propiedades pueden ser obtener acceso y se invocan a través de System.Reflection siempre que el código sea de plena confianza.

Puede utilizar Type.InvokeMember para establecer un campo en un valor concreto especificando BindingFlags.SetField. Por ejemplo, si desea establecer un campo de instancia pública denominado F en la clase C y F es una String, puede utilizar código como:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {"strings new value"});

Si F es un String[], puede utilizar código como:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {new String[]{"a","z","c","d"}});

que inicializará el campo F en esta nueva matriz. También puede utilizar Type.InvokeMember para establecer una posición en una matriz suministrando el índice del valor y, a continuación, el siguiente valor utilizando código como el siguiente:

typeof(C).InvokeMember("F", BindingFlags.SetField, null, c, new Object[] {1, "b"});

Esto cambiará la cadena "z" en la matriz que contiene F a la cadena "b".

Al invocar un IDispatch miembro, puede especificar el identificador DispID en lugar del nombre de miembro con el formato de cadena "[DispID = ##]". Por ejemplo, si el identificador DispID de MyComMethod es 3, puede especificar la cadena "[DispID = 3]" en lugar de "MyComMethod". Invocación de un miembro por DispID es más rápido que consultar el miembro por su nombre. En escenarios de agregación compleja, el identificador DispID es a veces la única forma de invocar al miembro deseado.

System_CAPS_noteNota

A partir de la .NET Framework 2.0 Service Pack 1, este método puede utilizarse para tener acceso a miembros no públicos si se ha concedido al llamador ReflectionPermission con el ReflectionPermissionFlag.RestrictedMemberAccess marca y si el conjunto de permisos de los miembros no públicos se restringe al llamador conceder el conjunto o un subconjunto de los mismos. (Vea Security Considerations for Reflection.)

Para utilizar esta funcionalidad, la aplicación debe utilizar .NET Framework 3.5 o posterior como destino.

En el ejemplo siguiente se utiliza InvokeMember para obtener acceso a miembros de un tipo.

using System;
using System.Reflection;

// This sample class has a field, constructor, method, and property.
class MyType 
{
    Int32 myField;
    public MyType(ref Int32 x) {x *= 5;}
    public override String ToString() {return myField.ToString();}
    public Int32 MyProp 
    {
        get {return myField;}
        set 
        { 
            if (value < 1) 
                throw new ArgumentOutOfRangeException("value", value, "value must be > 0");
            myField = value;
        }
    }
}

class MyApp 
{
    static void Main() 
    {
        Type t = typeof(MyType);
        // Create an instance of a type.
        Object[] args = new Object[] {8};
        Console.WriteLine("The value of x before the constructor is called is {0}.", args[0]);
        Object obj = t.InvokeMember(null, 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.CreateInstance, null, null, args);
        Console.WriteLine("Type: " + obj.GetType().ToString());
        Console.WriteLine("The value of x after the constructor returns is {0}.", args[0]);

        // Read and write to a field.
        t.InvokeMember("myField", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.SetField, null, obj, new Object[] {5});
        Int32 v = (Int32) t.InvokeMember("myField", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.GetField, null, obj, null);
        Console.WriteLine("myField: " + v);

        // Call a method.
        String s = (String) t.InvokeMember("ToString", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.InvokeMethod, null, obj, null);
        Console.WriteLine("ToString: " + s);

        // Read and write a property. First, attempt to assign an
        // invalid value; then assign a valid value; finally, get
        // the value.
        try 
        {
            // Assign the value zero to MyProp. The Property Set 
            // throws an exception, because zero is an invalid value.
            // InvokeMember catches the exception, and throws 
            // TargetInvocationException. To discover the real cause
            // you must catch TargetInvocationException and examine
            // the inner exception. 
            t.InvokeMember("MyProp", 
                BindingFlags.DeclaredOnly | 
                BindingFlags.Public | BindingFlags.NonPublic | 
                BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] {0});
        } 
        catch (TargetInvocationException e) 
        {
            // If the property assignment failed for some unexpected
            // reason, rethrow the TargetInvocationException.
            if (e.InnerException.GetType() != 
                typeof(ArgumentOutOfRangeException)) 
                throw;
            Console.WriteLine("An invalid value was assigned to MyProp.");
        }
        t.InvokeMember("MyProp", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.SetProperty, null, obj, new Object[] {2});
        v = (Int32) t.InvokeMember("MyProp", 
            BindingFlags.DeclaredOnly | 
            BindingFlags.Public | BindingFlags.NonPublic | 
            BindingFlags.Instance | BindingFlags.GetProperty, null, obj, null);
        Console.WriteLine("MyProp: " + v);
    }
}

ReflectionPermission

for accessing non-public members when the grant set of the non-public members is restricted to the caller's grant set, or a subset thereof. Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.RestrictedMemberAccess

ReflectionPermission

for accessing non-public members regardless of their grant set. Associated enumeration: F:System.Security.Permissions.ReflectionPermissionFlag.MemberAccess

SecurityPermission

to call unmanaged code. Associated enumeration: F:System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode

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