Type.InvokeMember Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Invoca um membro específico do Type atual.

Sobrecargas

InvokeMember(String, BindingFlags, Binder, Object, Object[])	Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos especificada.
InvokeMember(String, BindingFlags, Binder, Object, Object[], CultureInfo)	Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos e cultura especificadas.
InvokeMember(String, BindingFlags, Binder, Object, Object[], ParameterModifier[], CultureInfo, String[])	Quando substituído em uma classe derivada, invoca o membro especificado usando as restrições de associação especificadas e correspondendo a cultura, modificadores e lista de argumentos especificados.

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

Origem:: Type.cs

Origem:: Type.cs

Origem:: Type.cs

Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos especificada.

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

A cadeia de caracteres que contém o nome do construtor, método, propriedade ou membro de campo a serem invocados.

- ou -

Uma cadeia de caracteres vazia ("") para invocar o membro padrão.

- ou -

Para membros IDispatch, uma cadeia de caracteres que representa a DispID, por exemplo "[DispID=3]".

invokeAttr: BindingFlags

Uma combinação bit a bit dos valores de enumeração que especificam como a pesquisa é realizada. O acesso pode ser um dos BindingFlags, como Public, NonPublic, Private, InvokeMethod, GetField e assim por diante. O tipo de pesquisa não precisa ser especificado. Se o tipo de pesquisa for omitido, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static serão usados.

binder: Binder

Um objeto que define um conjunto de propriedades e habilita a associação, que pode envolver seleção de um método sobrecarregado, coerção de tipos de argumento e invocação de um membro por meio da reflexão.

- ou -

Uma referência nula (Nothing no Visual Basic), para usar o DefaultBinder. Observe que a definição explícita de um objeto Binder poderá ser necessária para invocar com êxito sobrecargas de método com argumentos de variável.

target: Object

O objeto no qual invocar o membro especificado.

args: Object[]

Uma matriz que contém os argumentos que serão passados para o membro a ser invocado.

Retornos

Object

Um objeto que representa o valor retornado do membro invocado.

Implementações

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

Exceções

ArgumentNullException

invokeAttr não contém CreateInstance e name é null.

ArgumentException

invokeAttr não é um atributo BindingFlags válido.

- ou -

invokeAttr não contém um dos seguintes sinalizadores de associação: InvokeMethod, CreateInstance, GetField, SetField, GetPropertyou SetProperty.

- ou -

invokeAttr contém CreateInstance combinado com InvokeMethod, GetField, SetField, GetPropertyou SetProperty.

- ou -

invokeAttr contém GetField e SetField.

- ou -

invokeAttr contém GetProperty e SetProperty.

- ou -

invokeAttr contém InvokeMethod combinado com SetField ou SetProperty.

- ou -

invokeAttr contém SetField e args tem mais de um elemento.

- ou -

Esse método é chamado em um objeto COM e um dos seguintes sinalizadores de associação não foi passado: BindingFlags.InvokeMethod, BindingFlags.GetProperty, BindingFlags.SetProperty, BindingFlags.PutDispProperty ou BindingFlags.PutRefDispProperty.

- ou -

Uma das matrizes de parâmetro nomeadas contém uma cadeia de caracteres que é null.

MethodAccessException

O membro especificado é um inicializador de classe.

MissingFieldException

Não é possível encontrar o campo nem a propriedade.

MissingMethodException

Não é possível encontrar nenhum método que corresponde aos argumentos em args.

- ou -

O atual objeto Type representa um tipo que contém os parâmetros de tipo aberto, ou seja, ContainsGenericParameters retorna true.

TargetException

O membro especificado não pode ser invocado no target.

AmbiguousMatchException

Mais de um método corresponde aos critérios de associação.

NotSupportedException

No momento, o .NET Compact Framework não dá suporte a esse método.

InvalidOperationException

O método representado pelo name tem um ou mais parâmetros de tipo genérico não especificados. Ou seja, a propriedade ContainsGenericParameters do método retorna true.

Exemplos

O exemplo a seguir usa para acessar membros InvokeMember de um 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

Comentários

Observação

Você não pode usar InvokeMember para invocar um método genérico.

Os seguintes sinalizadores de filtro BindingFlags podem ser usados para definir quais membros devem ser incluídos na pesquisa:

Especifique BindingFlags.Public para incluir membros públicos na pesquisa.
Especifique BindingFlags.NonPublic para incluir membros não públicos (ou seja, membros privados e protegidos) na pesquisa.
Especifique BindingFlags.FlattenHierarchy para incluir membros estáticos na hierarquia.

Os seguintes sinalizadores de modificador BindingFlags podem ser usados para alterar como a pesquisa funciona:

BindingFlags.IgnoreCase para ignorar o caso de name.
BindingFlags.DeclaredOnly para pesquisar apenas os membros declarados no Type, não os membros que foram simplesmente herdados.

Os seguintes BindingFlags sinalizadores de invocação podem ser usados para indicar qual ação tomar com o membro:

CreateInstance para invocar um construtor. name é ignorado. Não é válido com outros sinalizadores de invocação.
InvokeMethod para invocar um método, mas não um construtor ou um inicializador de tipo. Não é válido com SetField ou SetProperty. Se InvokeMethod for especificado por si só, BindingFlags.Public, BindingFlags.Instancee BindingFlags.Static serão incluídos automaticamente.
GetField para obter o valor de um campo. Não é válido com SetField.
SetField para definir o valor de um campo. Não é válido com GetField.
GetProperty para obter uma propriedade. Não é válido com SetProperty.
SetProperty para definir uma propriedade. Não é válido com GetProperty.

Consulte System.Reflection.BindingFlags para obter mais informações.

Um método será invocado se ambas as seguintes condições forem verdadeiras:

O número de parâmetros na declaração de método é igual ao número de argumentos na args matriz (a menos que os argumentos padrão sejam definidos no membro e BindingFlags.OptionalParamBinding sejam especificados).
O tipo de cada argumento pode ser convertido pelo associador para o tipo do parâmetro.

O associador encontrará todos os métodos correspondentes. Esses métodos são encontrados com base no tipo de associação solicitada (BindingFlags valores InvokeMethod, GetPropertye assim por diante). O conjunto de métodos é filtrado pelo nome, número de argumentos e um conjunto de modificadores de pesquisa definidos no associador.

Depois que o método é selecionado, ele é invocado. A acessibilidade é verificada nesse ponto. A pesquisa pode controlar qual conjunto de métodos é pesquisado com base no atributo de acessibilidade associado ao método . O Binder.BindToMethod método da Binder classe é responsável por selecionar o método a ser invocado. O associador padrão seleciona a correspondência mais específica.

As restrições de acesso são ignoradas para código totalmente confiável; ou seja, construtores privados, métodos, campos e propriedades podem ser acessados e invocados por meio System.Reflection de sempre que o código é totalmente confiável.

Você pode usar Type.InvokeMember para definir um campo para um valor específico especificando BindingFlags.SetField. Por exemplo, se você quiser definir um campo de instância pública chamado F na classe C e F for um String, poderá usar código como:

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

Se F for um String[], você poderá usar código como:

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

que inicializará o campo F para essa nova matriz. Você também pode usar Type.InvokeMember para definir uma posição em uma matriz fornecendo o índice do valor e, em seguida, o próximo valor usando código como o seguinte:

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

Isso alterará a cadeia de caracteres "z" na matriz que F contém para a cadeia de caracteres "b".

Ao invocar um IDispatch membro, você pode especificar o DispID em vez do nome do membro, usando o formato de cadeia de caracteres "[DispID=##]". Por exemplo, se o DispID de MyComMethod for 3, você poderá especificar a cadeia de caracteres "[DispID=3]" em vez de "MyComMethod". Invocar um membro pelo DispID é mais rápido do que procurar o membro pelo nome. Em cenários de agregação complexos, o DispID às vezes é a única maneira de invocar o membro desejado.

Observação

A partir do .NET Framework 2.0 Service Pack 1, esse método poderá ser usado para acessar membros não públicos se o chamador tiver sido concedido ReflectionPermission com o ReflectionPermissionFlag.RestrictedMemberAccess sinalizador e se o conjunto de concessões dos membros não públicos estiver restrito ao conjunto de concessões do chamador ou a um subconjunto dele. (Consulte Considerações de segurança para reflexão.)

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3.5 ou posterior.

Confira também

Aplica-se a

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

Origem:: Type.cs

Origem:: Type.cs

Origem:: Type.cs

Invoca o membro especificado, usando as restrições de associação especificadas e fazendo a correspondência da lista de argumentos e cultura 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

A cadeia de caracteres que contém o nome do construtor, método, propriedade ou membro de campo a serem invocados.

- ou -

Uma cadeia de caracteres vazia ("") para invocar o membro padrão.

- ou -

Para membros IDispatch, uma cadeia de caracteres que representa a DispID, por exemplo "[DispID=3]".

invokeAttr: BindingFlags

binder: Binder

- ou -

target: Object

O objeto no qual invocar o membro especificado.

args: Object[]

Uma matriz que contém os argumentos que serão passados para o membro a ser invocado.

culture: CultureInfo

O objeto que representa a localidade de globalização a ser usada, que pode ser necessária para realizar conversões específicas de localidade, como converter uma String numérica em uma Double.

- ou -

Uma referência nula (Nothing no Visual Basic) para usar o CultureInfo do thread atual.

Retornos

Object

Um objeto que representa o valor retornado do membro invocado.

Implementações

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

Exceções

ArgumentNullException

invokeAttr não contém CreateInstance e name é null.

ArgumentException

invokeAttr não é um atributo BindingFlags válido.

- ou -

invokeAttr não contém um dos seguintes sinalizadores de associação: InvokeMethod, CreateInstance, GetField, SetField, GetPropertyou SetProperty.

- ou -

invokeAttr contém CreateInstance combinado com InvokeMethod, GetField, SetField, GetPropertyou SetProperty.

- ou -

invokeAttr contém GetField e SetField.

- ou -

invokeAttr contém GetProperty e SetProperty.

- ou -

invokeAttr contém InvokeMethod combinado com SetField ou SetProperty.

- ou -

invokeAttr contém SetField e args tem mais de um elemento.

- ou -

Uma das matrizes de parâmetro nomeadas contém uma cadeia de caracteres que é null.

MethodAccessException

O membro especificado é um inicializador de classe.

MissingFieldException

Não é possível encontrar o campo nem a propriedade.

MissingMethodException

Não é possível encontrar nenhum método que corresponde aos argumentos em args.

- ou -

O atual objeto Type representa um tipo que contém os parâmetros de tipo aberto, ou seja, ContainsGenericParameters retorna true.

TargetException

O membro especificado não pode ser invocado no target.

AmbiguousMatchException

Mais de um método corresponde aos critérios de associação.

InvalidOperationException

O método representado pelo name tem um ou mais parâmetros de tipo genérico não especificados. Ou seja, a propriedade ContainsGenericParameters do método retorna true.

Comentários

Embora o associador padrão não processe CultureInfo (o parâmetro culture ), é possível usar a classe abstrata System.Reflection.Binder para gravar um associador personalizado que processa culture.

Observação

Você não pode usar InvokeMember para invocar um método genérico.

Os seguintes sinalizadores de filtro BindingFlags podem ser usados para definir quais membros devem ser incluídos na pesquisa:

Especifique BindingFlags.Public para incluir membros públicos na pesquisa.
Especifique BindingFlags.NonPublic para incluir membros não públicos (ou seja, membros particulares, internos e protegidos) na pesquisa.
Especifique BindingFlags.FlattenHierarchy para incluir membros estáticos na hierarquia.

Os seguintes sinalizadores de modificador BindingFlags podem ser usados para alterar como a pesquisa funciona:

BindingFlags.IgnoreCase para ignorar o caso de name.
BindingFlags.DeclaredOnly para pesquisar apenas os membros declarados no Type, não os membros que foram simplesmente herdados.

Os seguintes BindingFlags sinalizadores de invocação podem ser usados para indicar qual ação tomar com o membro:

CreateInstance para invocar um construtor. name é ignorado. Não é válido com outros sinalizadores de invocação.
InvokeMethod para invocar um método, mas não um construtor ou um inicializador de tipo. Não válido com SetField ou SetProperty. Se InvokeMethod for especificado por si só, BindingFlags.Public, BindingFlags.Instancee BindingFlags.Static serão incluídos automaticamente.
GetField para obter o valor de um campo. Não válido com SetField.
SetField para definir o valor de um campo. Não válido com GetField.
GetProperty para obter uma propriedade. Não válido com SetProperty.
SetProperty para definir uma propriedade. Não válido com GetProperty.

Consulte System.Reflection.BindingFlags para obter mais informações.

Um método será invocado se ambas as seguintes condições forem verdadeiras:

O número de parâmetros na declaração de método é igual ao número de argumentos na args matriz (a menos que os argumentos padrão sejam definidos no membro e BindingFlags.OptionalParamBinding sejam especificados).
O tipo de cada argumento pode ser convertido pelo associador para o tipo do parâmetro .

O associador encontrará todos os métodos correspondentes. Esses métodos são encontrados com base no tipo de associação solicitada (BindingFlags valores InvokeMethod, GetPropertye assim por diante). O conjunto de métodos é filtrado pelo nome, pelo número de argumentos e por um conjunto de modificadores de pesquisa definidos no associador.

Depois que o método é selecionado, ele é invocado. A acessibilidade é verificada nesse ponto. A pesquisa pode controlar qual conjunto de métodos são pesquisados com base no atributo de acessibilidade associado ao método . O Binder.BindToMethod método da Binder classe é responsável por selecionar o método a ser invocado. O associador padrão seleciona a correspondência mais específica.

As restrições de acesso são ignoradas para código totalmente confiável; ou seja, construtores privados, métodos, campos e propriedades podem ser acessados e invocados por meio de Reflexão sempre que o código for totalmente confiável.

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

Se F for um String[], você poderá usar código como:

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

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

Isso alterará a cadeia de caracteres "z" na matriz que F contém para a cadeia de caracteres "b".

Observação

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3.5 ou posterior.

Confira também

Aplica-se a

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

Origem:: Type.cs

Origem:: Type.cs

Origem:: Type.cs

Quando substituído em uma classe derivada, invoca o membro especificado usando as restrições de associação especificadas e correspondendo a cultura, modificadores e lista de argumentos especificados.

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

A cadeia de caracteres que contém o nome do construtor, método, propriedade ou membro de campo a serem invocados.

- ou -

Uma cadeia de caracteres vazia ("") para invocar o membro padrão.

- ou -

Para membros IDispatch, uma cadeia de caracteres que representa a DispID, por exemplo "[DispID=3]".

invokeAttr: BindingFlags

binder: Binder

- ou -

Uma referência nula (Nothing no Visual Basic) para usar o DefaultBinder. Observe que a definição explícita de um objeto Binder poderá ser necessária para invocar com êxito sobrecargas de método com argumentos de variável.

target: Object

O objeto no qual invocar o membro especificado.

args: Object[]

Uma matriz que contém os argumentos que serão passados para o membro a ser invocado.

modifiers: ParameterModifier[]

Uma matriz de objetos ParameterModifier que representam os atributos associados ao elemento correspondente na matriz args. Os atributos associados ao parâmetro são armazenados na assinatura do membro.

O associador padrão processa este parâmetro somente ao chamar um componente COM.

culture: CultureInfo

O objeto CultureInfo que representa a localidade de globalização a ser usada, que pode ser necessária para realizar conversões específicas de localidade, como converter uma String numérica em uma Double.

- ou -

Uma referência nula (Nothing no Visual Basic) para usar o CultureInfo do thread atual.

namedParameters: String[]

Uma matriz que contém os nomes dos parâmetros para os quais os valores na matriz args são passados.

Retornos

Object

Um objeto que representa o valor retornado do membro invocado.

Implementações

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

Exceções

ArgumentNullException

invokeAttr não contém CreateInstance e name é null.

ArgumentException

args e modifiers não têm o mesmo tamanho.

- ou -

invokeAttr não é um atributo BindingFlags válido.

- ou -

invokeAttr não contém um dos seguintes sinalizadores de associação: InvokeMethod, CreateInstance, GetField, SetField, GetPropertyou SetProperty.

- ou -

invokeAttr contém CreateInstance combinado com InvokeMethod, GetField, SetField, GetPropertyou SetProperty.

- ou -

invokeAttr contém GetField e SetField.

- ou -

invokeAttr contém GetProperty e SetProperty.

- ou -

invokeAttr contém InvokeMethod combinado com SetField ou SetProperty.

- ou -

invokeAttr contém SetField e args tem mais de um elemento.

- ou -

A matriz de parâmetros nomeados é maior que a matriz de argumentos.

- ou -

Uma das matrizes de parâmetro nomeadas contém uma cadeia de caracteres que é null.

MethodAccessException

O membro especificado é um inicializador de classe.

MissingFieldException

Não é possível encontrar o campo nem a propriedade.

MissingMethodException

Não é possível encontrar nenhum método que corresponde aos argumentos em args.

- ou -

Não foi possível encontrar nenhum membro com os nomes de argumentos fornecidos em namedParameters.

- ou -

O atual objeto Type representa um tipo que contém os parâmetros de tipo aberto, ou seja, ContainsGenericParameters retorna true.

TargetException

O membro especificado não pode ser invocado no target.

AmbiguousMatchException

Mais de um método corresponde aos critérios de associação.

InvalidOperationException

O método representado pelo name tem um ou mais parâmetros de tipo genérico não especificados. Ou seja, a propriedade ContainsGenericParameters do método retorna true.

Comentários

InvokeMember chama um membro do construtor ou um membro do método, obtém ou define um membro da propriedade, obtém ou define um membro do campo de dados ou obtém ou define um elemento de um membro da matriz.

Observação

Você não pode usar InvokeMember para invocar um método genérico.

Embora o associador padrão não processe ParameterModifier ou CultureInfo (os modifiers parâmetros e culture ), você pode usar a classe abstrata System.Reflection.Binder para escrever um associador personalizado que processa modifiers e culture. ParameterModifier só é usado ao chamar por meio da interoperabilidade COM, e somente os parâmetros passados por referência são tratados.

Cada parâmetro na matriz namedParameters obtém o valor no elemento correspondente na matriz args. Se o comprimento de args for maior que o de namedParameters, os valores de argumento restantes serão passados em ordem.

A namedParameters matriz pode ser usada para alterar a ordem dos argumentos em uma matriz de entrada. Por exemplo, dado o método M(string a, int b) (M(ByVal a As String, ByVal b As Integer) no Visual Basic) e a matriz { 42, "x" }de entrada , a matriz de entrada pode ser passada inalterada para args se a matriz { "b", "a" } for fornecida para namedParameters.

Os seguintes sinalizadores de filtro BindingFlags podem ser usados para definir quais membros devem ser incluídos na pesquisa:

Especifique BindingFlags.Public para incluir membros públicos na pesquisa.
Especifique BindingFlags.NonPublic para incluir membros não públicos (ou seja, membros particulares, internos e protegidos) na pesquisa.
Especifique BindingFlags.FlattenHierarchy para incluir membros estáticos na hierarquia.

Os seguintes sinalizadores de modificador BindingFlags podem ser usados para alterar como a pesquisa funciona:

BindingFlags.IgnoreCase para ignorar o caso de name.
BindingFlags.DeclaredOnly para pesquisar apenas os membros declarados no Type, não os membros que foram simplesmente herdados.

Os seguintes BindingFlags sinalizadores de invocação podem ser usados para indicar qual ação tomar com o membro:

CreateInstance para invocar um construtor. name é ignorado. Não é válido com outros sinalizadores de invocação.
InvokeMethod para invocar um método, mas não um construtor ou um inicializador de tipo. Não válido com SetField ou SetProperty. Se InvokeMethod for especificado por si só, BindingFlags.Public, BindingFlags.Instancee BindingFlags.Static serão incluídos automaticamente.
GetField para obter o valor de um campo. Não válido com SetField.
SetField para definir o valor de um campo. Não válido com GetField.
GetProperty para obter uma propriedade. Não válido com SetProperty.
SetProperty para definir uma propriedade. Não válido com GetProperty.

Consulte System.Reflection.BindingFlags para obter mais informações.

Um método será invocado se ambas as seguintes condições forem verdadeiras:

O número de parâmetros na declaração de método é igual ao número de argumentos na args matriz (a menos que os argumentos padrão sejam definidos no membro e BindingFlags.OptionalParamBinding sejam especificados).
O tipo de cada argumento pode ser convertido pelo associador para o tipo do parâmetro .

O associador encontrará todos os métodos correspondentes. Esses métodos são encontrados com base no tipo de associação solicitada (BindingFlags valores InvokeMethod, GetPropertye assim por diante). O conjunto de métodos é filtrado pelo nome, pelo número de argumentos e por um conjunto de modificadores de pesquisa definidos no associador.

InvokeMember pode ser usado para invocar métodos com parâmetros que têm valores padrão. Para associar a esses métodos, Reflection precisa BindingFlags.OptionalParamBinding ser especificado. Para um parâmetro que tem um valor padrão, você pode fornecer um valor diferente ou fornecer Missing.Value para usar o valor padrão.

Por exemplo, considere um método como MyMethod(int x, float y = 2.0). Para invocar esse método apenas com o primeiro argumento como MyMethod(4), passe um dos sinalizadores de associação acima e passe dois argumentos, ou seja, 4 para o primeiro argumento e Missing.Value para o segundo argumento. A menos que você use Missing.Value, não poderá omitir parâmetros opcionais com o Invoke método . Se você precisar fazer isso, use InvokeMember em vez disso.

As restrições de acesso são ignoradas para código totalmente confiável; ou seja, construtores privados, métodos, campos e propriedades podem ser acessados e invocados sempre System.Reflection que o código for totalmente confiável.

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

Se F for um String[], você poderá usar código como:

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

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

Isso alterará a cadeia de caracteres "z" na matriz que F contém para a cadeia de caracteres "b".

Observação

Para usar essa funcionalidade, seu aplicativo deve ter como destino o .NET Framework 3.5 ou posterior.

Confira também

Aplica-se a

Partilhar via

Type.InvokeMember Método

Definição

Sobrecargas

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

Parâmetros

Retornos

Implementações

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

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

Parâmetros

Retornos

Implementações

Exceções

Comentários

Confira também

Aplica-se a

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

Parâmetros

Retornos

Implementações

Exceções

Comentários

Confira também

Aplica-se a

Recursos adicionais