Compartir a través de

Type.InvokeMember Método

  • Referencia

Definición

Espacio de nombres:
System
Ensamblado:
System.Runtime.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll

Invoca a un miembro específico del objeto Type actual.

Sobrecargas

InvokeMember(String, BindingFlags, Binder, Object, Object[])

Invoca al miembro especificado, aplica las restricciones de enlace igualmente especificadas y compara la lista de argumentos indicada.
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Invoca al miembro especificado, aplica las restricciones de enlace especificadas y compara la lista de argumentos y la referencia cultural igualmente especificadas.
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Cuando se invalida en una clase derivada, invoca al miembro especificado, aplica las restricciones de enlace igualmente especificadas y realiza una comparación con la lista de argumentos, los modificadores y la referencia cultural indicados.

InvokeMember(String, BindingFlags, Binder, Object, Object[])

Source:
Type.cs
Source:
Type.cs
Source:
Type.cs

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

public:
 System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args);
public:
 virtual System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args);
public object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args);
public object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args);
member this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj
abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj
override this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] -> obj
Public Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object()) As Object

Parámetros

name
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
BindingFlags

Combinación bit a bit de los valores de enumeración que especifican cómo 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
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
Object

Objeto donde debe invocarse al miembro especificado.

args
Object[]

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

Devoluciones

Object

Objeto que representa el valor devuelto del miembro invocado.

Implementaciones

InvokeMember(String, BindingFlags, Binder, Object, Object[])

Excepciones

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.

Ejemplos

En el ejemplo siguiente se usa InvokeMember para tener acceso a los miembros de un tipo.

using namespace System;
using namespace System::Reflection;

// This sample class has a field, constructor, method, and property.
ref class MyType
{
private:
   Int32 myField;

public:
   MyType( interior_ptr<Int32> x )
   {
       *x *= 5;
   }

   virtual String^ ToString() override
   {
      return myField.ToString();
   }

   property Int32 MyProp 
   {
      Int32 get()
      {
         return myField;
      }

      void set( Int32 value )
      {
         if ( value < 1 )
                  throw gcnew ArgumentOutOfRangeException( "value",value,"value must be > 0" );

         myField = value;
      }
   }
};

int main()
{
   Type^ t = MyType::typeid;

   // Create an instance of a type.
   array<Object^>^args = {8};
   Console::WriteLine( "The value of x before the constructor is called is {0}.", args[ 0 ] );
   Object^ obj = t->InvokeMember( nullptr, static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::CreateInstance), nullptr, nullptr, args );
   Console::WriteLine( "Type: {0}", obj->GetType() );
   Console::WriteLine( "The value of x after the constructor returns is {0}.", args[ 0 ] );

   // Read and write to a field.
   array<Object^>^obj5 = {5};
   t->InvokeMember( "myField", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetField), nullptr, obj, obj5 );
   Int32 v = safe_cast<Int32>(t->InvokeMember( "myField", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::GetField), nullptr, obj, nullptr ));
   Console::WriteLine( "myField: {0}", v );

   // Call a method.
   String^ s = safe_cast<String^>(t->InvokeMember( "ToString", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::InvokeMethod), nullptr, obj, nullptr ));
   Console::WriteLine( "ToString: {0}", 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. 
      array<Object^>^obj0 = {(int^)0};
      t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetProperty), nullptr, obj, obj0 );
   }
   catch ( TargetInvocationException^ e ) 
   {
      // If the property assignment failed for some unexpected
      // reason, rethrow the TargetInvocationException.
      if ( e->InnerException->GetType() != ArgumentOutOfRangeException::typeid )
            throw;

      Console::WriteLine( "An invalid value was assigned to MyProp." );
   }

   array<Object^>^obj2 = {2};
   t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::SetProperty), nullptr, obj, obj2 );
   v =  safe_cast<Int32>(t->InvokeMember( "MyProp", static_cast<BindingFlags>(BindingFlags::DeclaredOnly | BindingFlags::Public | BindingFlags::NonPublic | BindingFlags::Instance | BindingFlags::GetProperty), nullptr, obj, nullptr ));
   Console::WriteLine( "MyProp: {0}", v );
}

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

open System
open System.Reflection

// This sample class has a field, constructor, method, and property.
type MyType() =
    let mutable myField = 0

    member _.MyType(x: int byref) =
        x <- x * 5
    
    override _.ToString() =
        string myField
    
    member _.MyProp
        with get () = myField
        and set value =
            if value < 1 then
                raise (ArgumentOutOfRangeException("value", value, "value must be > 0"))
            myField <- value

let t = typeof<MyType>
// Create an instance of a type.
let args = Array.zeroCreate<obj> 8
printfn $"The value of x before the constructor is called is {args[0]}."
let obj = t.InvokeMember(null,
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.CreateInstance, null, null, args)
printfn $"Type: {obj.GetType()}"
printfn $"The value of x after the constructor returns is {args[0]}."

// Read and write to a field.
t.InvokeMember("myField",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.SetField, null, obj, Array.zeroCreate<obj> 5) |> ignore
let v = t.InvokeMember("myField",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.GetField, null, obj, null) :?> int
printfn $"myField: {v}"

// Call a method.
let s = t.InvokeMember("ToString",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.InvokeMethod, null, obj, null) :?> string
printfn $"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, Array.zeroCreate<obj> 0) |> ignore
with :? TargetInvocationException as e ->
    // If the property assignment failed for some unexpected
    // reason, rethrow the TargetInvocationException.
    if e.InnerException.GetType() <> typeof<ArgumentOutOfRangeException> then
        reraise ()
    printfn "An invalid value was assigned to MyProp."
t.InvokeMember("MyProp",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.SetProperty, null, obj, Array.zeroCreate<obj> 2) |> ignore
let v2 = t.InvokeMember("MyProp",
    BindingFlags.DeclaredOnly |||
    BindingFlags.Public ||| BindingFlags.NonPublic |||
    BindingFlags.Instance ||| BindingFlags.GetProperty, null, obj, null)
printfn $"MyProp: {v2}"

Imports System.Reflection

' This sample class has a field, constructor, method, and property.
Class MyType
    Private myField As Int32

    Public Sub New(ByRef x As Int32)
        x *= 5
    End Sub

    Public Overrides Function ToString() As [String]
        Return myField.ToString()
    End Function 'ToString

    Public Property MyProp() As Int32
        Get
            Return myField
        End Get
        Set(ByVal Value As Int32)
            If Value < 1 Then
                Throw New ArgumentOutOfRangeException("value", Value, "value must be > 0")
            End If
            myField = Value
        End Set
    End Property
End Class

Class MyApp

    Shared Sub Main()
        Dim t As Type = GetType(MyType)
        ' Create an instance of a type.
        Dim args() As [Object] = {8}
        Console.WriteLine("The value of x before the constructor is called is {0}.", args(0))
        Dim obj As [Object] = t.InvokeMember(Nothing, BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.CreateInstance, Nothing, Nothing, args)
        Console.WriteLine("Type: {0}", 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 Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetField, Nothing, obj, New [Object]() {5})
        Dim v As Int32 = CType(t.InvokeMember("myField", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.GetField, Nothing, obj, Nothing), Int32)
        Console.WriteLine("myField: {0}", v)

        ' Call a method.
        Dim s As [String] = CType(t.InvokeMember("ToString", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.InvokeMethod, Nothing, obj, Nothing), [String])
        Console.WriteLine("ToString: {0}", 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 Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetProperty, Nothing, obj, New [Object]() {0})
        Catch e As TargetInvocationException
            ' If the property assignment failed for some unexpected
            ' reason, rethrow the TargetInvocationException.
            If Not e.InnerException.GetType() Is GetType(ArgumentOutOfRangeException) Then
                Throw
            End If
            Console.WriteLine("An invalid value was assigned to MyProp.")
        End Try
        t.InvokeMember("MyProp", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.SetProperty, Nothing, obj, New [Object]() {2})
        v = CType(t.InvokeMember("MyProp", BindingFlags.DeclaredOnly Or BindingFlags.Public Or BindingFlags.NonPublic Or BindingFlags.Instance Or BindingFlags.GetProperty, Nothing, obj, Nothing), Int32)
        Console.WriteLine("MyProp: {0}", v)
    End Sub
End Class

Comentarios

Nota

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

Las marcas de filtro siguientes BindingFlags se pueden usar para definir qué miembros se van a incluir en la búsqueda:

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

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

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

Se pueden usar las marcas modificadores siguientes BindingFlags para cambiar el funcionamiento de la búsqueda:

  • BindingFlags.IgnoreCase para pasar por alto el caso de name.

  • BindingFlags.DeclaredOnly para buscar solo los miembros declarados en Type, no los miembros que simplemente se heredaron.

Las marcas de invocación siguientes BindingFlags se pueden usar para indicar qué acción realizar con el miembro:

  • CreateInstance para invocar un constructor. name se pasa por alto. 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 por sí mismo, , BindingFlags.PublicBindingFlags.Instancey 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 invocará un método si se cumplen las dos condiciones siguientes:

  • El número de parámetros de la declaración de 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 especifique).

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

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

Una vez seleccionado el método, se invoca. La accesibilidad se comprueba en ese momento. La búsqueda puede controlar qué 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 la coincidencia más específica.

Las restricciones de acceso se omiten para el código de plena confianza; es decir, se puede tener acceso a constructores privados, métodos, campos y propiedades e invocarse a través System.Reflection de cada vez que el código sea de plena confianza.

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

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

Si F es , String[]puede usar 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 usar Type.InvokeMember para establecer una posición en una matriz proporcionando el índice del valor y, a continuación, el siguiente mediante código como el siguiente:

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

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

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

Nota

A partir de .NET Framework 2.0 Service Pack 1, este método se puede usar para acceder a miembros no públicos si se ha concedido ReflectionPermission al autor de la llamada con la ReflectionPermissionFlag.RestrictedMemberAccess marca y si el conjunto de concesión de los miembros no públicos está restringido al conjunto de concesión del autor de la llamada o a un subconjunto de ellos. (Consulte Consideraciones de seguridad para la reflexión).

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

Consulte también

Se aplica a

InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Source:
Type.cs
Source:
Type.cs
Source:
Type.cs

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

public:
 System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture);
public:
 virtual System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, System::Globalization::CultureInfo ^ culture);
public object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args, System.Globalization.CultureInfo? culture);
public object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Globalization.CultureInfo culture);
member this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj
abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj
override this.InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Globalization.CultureInfo -> obj
Public Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object(), culture As CultureInfo) As Object

Parámetros

name
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
BindingFlags

Combinación bit a bit de los valores de enumeración que especifican cómo 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
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
Object

Objeto donde debe invocarse al miembro especificado.

args
Object[]

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

culture
CultureInfo

Objeto que representa la configuración regional de globalización que se va a usar, que puede ser necesaria para las conversiones específicas de la configuración regional, como pasar un tipo numérico String a Double.

O bien

Referencia nula (Nothing en Visual Basic) para usar el CultureInfo del subproceso actual.

Devoluciones

Object

Objeto que representa el valor devuelto del miembro invocado.

Implementaciones

InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)

Excepciones

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.

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.

Comentarios

Aunque el enlazador predeterminado no procesa CultureInfo (el culture parámetro ), puede usar la clase abstracta System.Reflection.Binder para escribir un enlazador personalizado que procesa culture.

Nota

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

Las marcas de filtro siguientes BindingFlags se pueden usar para definir qué miembros se van a incluir en la búsqueda:

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

  • Especifique BindingFlags.NonPublic que incluya miembros no públicos (es decir, miembros privados, internos y protegidos) en la búsqueda.

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

Se pueden usar las marcas modificadores siguientes BindingFlags para cambiar el funcionamiento de la búsqueda:

  • BindingFlags.IgnoreCase para pasar por alto el caso de name.

  • BindingFlags.DeclaredOnly para buscar solo los miembros declarados en Type, no los miembros que simplemente se heredaron.

Las marcas de invocación siguientes BindingFlags se pueden usar para indicar qué acción realizar con el miembro:

  • CreateInstance para invocar un constructor. name se pasa por alto. 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 por sí mismo, , BindingFlags.PublicBindingFlags.Instancey 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 invocará un método si se cumplen las dos condiciones siguientes:

  • El número de parámetros de la declaración de 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 especifique).

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

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

Una vez seleccionado el método, se invoca. La accesibilidad se comprueba en ese momento. La búsqueda puede controlar qué 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 la coincidencia más específica.

Las restricciones de acceso se omiten para el código de plena confianza; es decir, se puede tener acceso a constructores privados, métodos, campos y propiedades e invocarse a través de Reflexión siempre que el código sea de plena confianza.

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

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

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

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

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

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

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

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

Nota

A partir de .NET Framework 2.0 Service Pack 1, este método se puede usar para acceder a miembros no públicos si se ha concedido ReflectionPermission al autor de la llamada con la ReflectionPermissionFlag.RestrictedMemberAccess marca y si el conjunto de concesión de los miembros no públicos está restringido al conjunto de concesión del autor de la llamada o a un subconjunto de ellos. (Consulte Consideraciones de seguridad para la reflexión).

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

Consulte también

Se aplica a

InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Source:
Type.cs
Source:
Type.cs
Source:
Type.cs

Cuando se invalida en una clase derivada, invoca al miembro especificado, aplica las restricciones de enlace igualmente especificadas y realiza una comparación con la lista de argumentos, los modificadores y la referencia cultural indicados.

public:
 abstract System::Object ^ InvokeMember(System::String ^ name, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, System::Object ^ target, cli::array <System::Object ^> ^ args, cli::array <System::Reflection::ParameterModifier> ^ modifiers, System::Globalization::CultureInfo ^ culture, cli::array <System::String ^> ^ namedParameters);
public abstract object? InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object? target, object?[]? args, System.Reflection.ParameterModifier[]? modifiers, System.Globalization.CultureInfo? culture, string[]? namedParameters);
public abstract object InvokeMember (string name, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder binder, object target, object[] args, System.Reflection.ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters);
abstract member InvokeMember : string * System.Reflection.BindingFlags * System.Reflection.Binder * obj * obj[] * System.Reflection.ParameterModifier[] * System.Globalization.CultureInfo * string[] -> obj
Public MustOverride Function InvokeMember (name As String, invokeAttr As BindingFlags, binder As Binder, target As Object, args As Object(), modifiers As ParameterModifier(), culture As CultureInfo, namedParameters As String()) As Object

Parámetros

name
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
BindingFlags

Combinación bit a bit de los valores de enumeración que especifican cómo 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
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
Object

Objeto donde debe invocarse al miembro especificado.

args
Object[]

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

modifiers
ParameterModifier[]

Matriz de objetos ParameterModifier que representan los atributos asociados al elemento correspondiente de la matriz args. Los atributos asociados a un parámetro se almacenan en la firma del miembro.

El enlazador predeterminado solo procesa este parámetro cuando se llama a un componente COM.

culture
CultureInfo

Objeto CultureInfo que representa la configuración regional de globalización que se va a usar, que puede ser necesaria para las conversiones específicas de la configuración regional, como pasar un tipo numérico String a Double.

O bien

Referencia nula (Nothing en Visual Basic) para usar el CultureInfo del subproceso actual.

namedParameters
String[]

Matriz que contiene los nombres de los parámetros a los que se pasan los valores de la matriz args.

Devoluciones

Object

Objeto que representa el valor devuelto del miembro invocado.

Implementaciones

InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[]) InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])

Excepciones

ArgumentNullException

invokeAttr no contiene CreateInstance y name es null.

ArgumentException

args y modifiers no tienen la misma longitud.

O bien

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

La matriz de parámetros con nombre es mayor que la matriz de argumentos.

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

No se puede encontrar ningún miembro con los nombres de argumento proporcionados en namedParameters.

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.

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.

Comentarios

InvokeMember llama a un miembro del constructor o a un miembro de método, obtiene o establece un miembro de propiedad, obtiene o establece un miembro de campo de datos, u obtiene o establece un elemento de un miembro de matriz.

Nota

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

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

Aunque el enlazador predeterminado no procesa ParameterModifier o (los modifiers parámetros yculture), puede usar la clase abstracta System.Reflection.Binder para escribir un enlazador personalizado que procesa modifiers y cultureCultureInfo . ParameterModifier solo se usa al llamar a través de la interoperabilidad COM y solo se controlan los parámetros que se pasan por referencia.

Cada parámetro de la matriz namedParameters obtiene el valor del elemento correspondiente en la matriz args. Si la longitud de args es mayor que la longitud de namedParameters, los valores de argumento restantes se pasan por orden.

La namedParameters matriz se puede usar para cambiar el orden de los argumentos en una matriz de entrada. Por ejemplo, dado el método M(string a, int b) (M(ByVal a As String, ByVal b As Integer) en Visual Basic) y la matriz { 42, "x" }de entrada , la matriz de entrada se puede pasar sin cambios a args si la matriz { "b", "a" } se proporciona para namedParameters.

Las marcas de filtro siguientes BindingFlags se pueden usar para definir qué miembros se van a incluir en la búsqueda:

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

  • Especifique BindingFlags.NonPublic que incluya miembros no públicos (es decir, miembros privados, internos y protegidos) en la búsqueda.

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

Se pueden usar las marcas modificadores siguientes BindingFlags para cambiar el funcionamiento de la búsqueda:

  • BindingFlags.IgnoreCase para pasar por alto el caso de name.

  • BindingFlags.DeclaredOnly para buscar solo los miembros declarados en Type, no los miembros que simplemente se heredaron.

Las siguientes BindingFlags marcas de invocación se pueden usar para indicar qué acción realizar con el miembro:

  • CreateInstance para invocar un constructor. name se pasa por alto. 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 por sí mismo, , BindingFlags.PublicBindingFlags.Instancey 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 invocará un método si se cumplen las dos condiciones siguientes:

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

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

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

Una vez seleccionado el método, se invoca. La accesibilidad se comprueba en ese momento. La búsqueda puede controlar qué 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 la coincidencia más específica.

InvokeMember se puede usar para invocar métodos con parámetros que tienen valores predeterminados. Para enlazar a estos métodos, reflection debe BindingFlags.OptionalParamBinding especificarse. Para un parámetro que tiene un valor predeterminado, puede proporcionar un valor diferente o proporcionar Missing.Value para usar el valor predeterminado.

Por ejemplo, considere un método como MyMethod(int x, float y = 2.0). Para invocar este método con solo el primer argumento como MyMethod(4), pase una de las marcas de enlace anteriores y pase dos argumentos, es decir, 4 para el primer argumento y Missing.Value para el segundo. A menos que use Missing.Value, es posible que no omita parámetros opcionales con el Invoke método . Si debe hacerlo, use InvokeMember en su lugar.

Las restricciones de acceso se omiten para el código de plena confianza; es decir, se puede tener acceso a constructores privados, métodos, campos y propiedades e invocarse a través System.Reflection de cada vez que el código sea de plena confianza.

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

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

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

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

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

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

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

Nota

A partir de .NET Framework 2.0 Service Pack 1, este método se puede usar para acceder a miembros no públicos si se ha concedido ReflectionPermission al autor de la llamada con la ReflectionPermissionFlag.RestrictedMemberAccess marca y si el conjunto de concesión de los miembros no públicos está restringido al conjunto de concesión del autor de la llamada o a un subconjunto de ellos. (Consulte Consideraciones de seguridad para la reflexión).

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

Consulte también

Se aplica a