Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original
Este tema aún no ha recibido ninguna valoración - Valorar este tema

Type.InvokeMember (Método) (String, BindingFlags, Binder, Object, Object[])

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
Tipo: 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 bien
Para los miembros de IDispatch, cadena que representa el identificador DispID, por ejemplo "[DispID=3]".
invokeAttr
Tipo: 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
Tipo: 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
Tipo: System.Object
Objeto donde debe invocarse al miembro especificado.
args
Tipo: System.Object[]
Matriz que contiene los argumentos que se van a pasar al miembro al cual se va a invocar.

Valor devuelto

Tipo: System.Object
Objeto que representa el valor devuelto del miembro invocado.

Implementaciones

_Type.InvokeMember(String, BindingFlags, Binder, Object, Object[])
ExcepciónCondición
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 marcas de enlace siguientes: InvokeMethod, CreateInstance, GetField, SetField, GetProperty o SetProperty.

O bien

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

O bien

invokeAttr contiene GetField y SetField.

O bien

invokeAttr contiene GetProperty y 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 llamó a este método desde un objeto COM y no se pasó 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 encuentra el campo ni la propiedad.

MissingMethodException

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

O bien

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

TargetException

No se puede invocar al miembro especificado en target.

AmbiguousMatchException

Hay más de un método que 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.

NotaNota

No puede utilizar InvokeMember para llamar a un método genérico.

Las siguientes marcas de filtro BindingFlags pueden utilizarse para definir los miembros que van a incluirse en la búsqueda:

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

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

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

Las siguientes marcas de modificación BindingFlags pueden utilizarse para cambiar la forma en que se lleva a cabo la búsqueda:

  • BindingFlags.IgnoreCase para pasar por alto la distinción entre mayúsculas y minúsculas de name.

  • BindingFlags.DeclaredOnly para buscar solo los miembros declarados en el objeto Type, no los miembros que simplemente se han heredado.

Se pueden utilizar las siguientes marcas de invocación BindingFlags para denotar la acción que se realizará con el miembro:

  • CreateInstance para llamar a un constructor. Se omite name. No es válido con otras marcas 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 a sí mismo, se incluyen automáticamente BindingFlags.Public, BindingFlags.Instance y BindingFlags.Static.

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

Para obtener más información, consulte System.Reflection.BindingFlags.

Un método se invocará si se cumplen las dos condiciones siguientes:

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

  • El enlazador puede convertir el tipo de cada argumento en el tipo del parámetro.

El enlazador encontrará todos los métodos que coincidan. Estos métodos se buscan en función del tipo de enlace que se solicite (valores InvokeMethod, GetProperty de BindingFlags, entre otros). El conjunto de métodos se filtra por nombre, número de argumentos y un conjunto de modificadores de búsqueda definidos en el enlazador.

Una vez seleccionado el método, se llama al mismo. Llegados a este punto se comprueba la accesibilidad. La búsqueda puede controlar el conjunto de métodos que se buscan a partir del atributo de accesibilidad asociado al método. El método Binder.BindToMethod de la clase Binder es responsable de seleccionar el método al que se va a invocar. El enlazador predeterminado selecciona la coincidencia más específica.

Las restricciones de acceso no se tienen en cuenta para el código de plena confianza; es decir, se puede obtener acceso y llamar a constructores privados, métodos, campos y propiedades a través de System.Reflection siempre que el código sea de plena confianza.

Type.InvokeMember puede utilizarse para asignar un valor determinado a un campo si se especifica BindingFlags.SetField. Por ejemplo, si se desea establecer un campo de instancia pública denominado F en una clase C y F es de tipo String, se puede utilizar código como el siguiente:

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

Si F es de tipo String[], se puede utilizar código como el siguiente:

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. Asimismo, se puede utilizar Type.InvokeMember para establecer una posición en una matriz si se suministra el índice del valor y, a continuación, el siguiente valor mediante un código como el indicado a continuación:

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

De esta forma, se cambia la cadena "z" de la matriz que contiene F a la cadena "b".

Cuando se invoca a un miembro de IDispatch, se puede especificar el identificador DispID en lugar del nombre del miembro si se utiliza el formato de cadena "[DispID=##]". Por ejemplo, si el identificador DispID de MyComMethod es 3, se puede especificar la cadena "[DispID=3]" en lugar de "MyComMethod". Es más rápido invocar a un miembro por DispID que consultar el miembro por nombre. En escenarios de agregación compleja, el identificador DispID es a veces el único modo de invocar al miembro deseado.

NotaNota

A partir de .NET Framework 2.0 Service Pack 1, este método se puede usar para obtener acceso a los miembros no públicos si se ha concedido al llamador ReflectionPermission con el marcador ReflectionPermissionFlag.RestrictedMemberAccess y si el conjunto de permisos concedidos de los miembros no públicos se restringe al conjunto de permisos concedidos del llamador o a un subconjunto de los mismos. (Vea Consideraciones de seguridad sobre la reflexión.)

Para usar esta funcionalidad, el destino de la aplicación debe ser .NET Framework 3.5 o posterior.

En el siguiente ejemplo, se utiliza InvokeMember para obtener acceso a los 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);
    }
}


.NET Framework

Compatible con: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
¿Te ha resultado útil?
(Caracteres restantes: 1500)
Gracias por sus comentarios

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft. Reservados todos los derechos.