Type.InvokeMember Método

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

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

Devoluciones

Objeto que representa el valor devuelto del miembro invocado.

Implementaciones

Excepciones

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

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.

Consulte también

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

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

Devoluciones

Objeto que representa el valor devuelto del miembro invocado.

Implementaciones

Excepciones

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.

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.

Consulte también

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission

Source:

Type.cs

Source:

Type.cs

Source:

Type.cs

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

Devoluciones

Objeto que representa el valor devuelto del miembro invocado.

Implementaciones

Excepciones

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.

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

Consulte también

• String
• Binder
• DefaultBinder
• BindingFlags
• ParameterModifier
• ParameterAttributes
• CultureInfo
• ReflectionPermission