Type.InvokeMember Método

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

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

Devoluções

Um objeto que representa o valor de retorno do membro invocado.

Implementações

Exceções

Observações

InvokeMember chama um membro construtor ou um membro de método, obtém ou define um membro de propriedade, obtém ou definem um membro de campo de dados, ou obtém ou definem um elemento de um membro de array.

Quando invoca um IDispatch membro, pode especificar o DispID em vez do nome do membro, usando o formato de string "[DispID=##]". Por exemplo, se o DispID do MyComMethod for 3, pode especificar a cadeia "[DispID=3]" em vez de "MyComMethod". Invocar um membro por DispID é mais rápido do que procurar o membro pelo nome. Em cenários complexos de agregação, o DispID é por vezes a única forma de invocar o membro desejado.

Embora o binder padrão não processe ParameterModifier ou CultureInfo (os modifiers parâmetros e), culture pode usar a classe abstract System.Reflection.Binder para escrever um binder personalizado que processe modifiers e culture. ParameterModifier é utilizado apenas ao fazer chamadas através da interoperabilidade COM, e apenas os parâmetros que são passados por referência são tratados.

Cada parâmetro no namedParameters array recebe o valor no elemento correspondente do args array. Se o comprimento de args for maior que o comprimento de namedParameters, os valores restantes dos argumentos são passados por ordem.

O namedParameters array pode ser usado para alterar a ordem dos argumentos num array de entrada. Por exemplo, dado o método M(string a, int b) (M(ByVal a As String, ByVal b As Integer) em Visual Basic) e o array de entrada { 42, "x" }, o array de entrada pode ser passado inalterado para args se o array { "b", "a" } for fornecido para namedParameters.

As seguintes BindingFlags bandeiras de filtro podem ser usadas para definir quais os membros a incluir na pesquisa:

• Especifique BindingFlags.Public incluir membros públicos na pesquisa.

• Especifique BindingFlags.NonPublic incluir membros não públicos (ou seja, privados, internos e protegidos) na busca.

• Especifique BindingFlags.FlattenHierarchy incluir membros estáticos na hierarquia.

Os seguintes BindingFlags sinalizadores modificadores podem ser usados para alterar o funcionamento da pesquisa:

• BindingFlags.IgnoreCase ignorar o caso de name.

• BindingFlags.DeclaredOnly para procurar apenas os membros declarados no Type, não os membros que foram simplesmente herdados.

As seguintes BindingFlags bandeiras de invocação podem ser usadas para indicar que ação tomar com o membro:

• CreateInstance invocar um construtor. name é ignorado. Não é válido com outras bandeiras de invocação.

• InvokeMethod invocar um método, mas não um construtor ou inicializador de tipos. Não válido com SetField ou SetProperty. Se InvokeMethod for especificado por si próprio, BindingFlags.Public, BindingFlags.Instance, e BindingFlags.Static são automaticamente incluídos.

• 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 adquirir uma propriedade. Não é válido com SetProperty.

• SetProperty para estabelecer 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 do método é igual ao número de argumentos no args array (a menos que os argumentos padrão estejam definidos no membro e BindingFlags.OptionalParamBinding estejam especificados).

• O tipo de cada argumento pode ser convertido pelo ligador para o tipo do parâmetro.

O binder vai encontrar todos os métodos de correspondência. Estes métodos são encontrados com base no tipo de ligação requerida (BindingFlags valores InvokeMethod, GetProperty, e assim sucessivamente). O conjunto de métodos é filtrado pelo nome, número de argumentos e um conjunto de modificadores de pesquisa definidos no binder.

Depois de selecionado o método, é invocado. A acessibilidade é verificada nesse ponto. A pesquisa pode controlar que 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 dossier padrão seleciona a correspondência mais específica.

InvokeMember pode ser usado para invocar métodos com parâmetros que têm valores por defeito. Para se ligar a estes métodos, é necessário BindingFlags.OptionalParamBinding especificar a Reflexão. Para um parâmetro que tem um valor predefinido, podes fornecer um valor diferente ou fornecer Missing.Value para usar o valor predefinido.

Por exemplo, considere um método como MyMethod(int x, float y = 2.0). Para invocar este método apenas com o primeiro argumento como MyMethod(4), passe uma das bandeiras de ligação acima e passe dois argumentos, nomeadamente, 4 para o primeiro argumento e Missing.Value para o segundo argumento. A menos que use Missing.Value, não pode omitir parâmetros opcionais com o Invoke método. Se for preciso, 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 acedidos e invocados sempre System.Reflection que o código for totalmente confiável.

Pode usar Type.InvokeMember para definir um campo com um valor específico especificando BindingFlags.SetField. Por exemplo, se quiseres definir um campo de instância pública chamado F na classe C, e F é um String, podes usar código como:

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

Se F for a String[], pode 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á o campo F nesta nova matriz. Também pode usar Type.InvokeMember para definir uma posição num array fornecendo o índice do valor e depois o valor seguinte, usando código como o seguinte:

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

Isto altera a sequência "z" no array que F mantém para a cadeia "b".

Ver também

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

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

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

member 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

Devoluções

Um objeto que representa o valor de retorno do membro invocado.

Implementações

Exceções

Observações

Embora o fichário padrão não processe CultureInfo (o culture parâmetro), você pode usar a classe abstrata System.Reflection.Binder para escrever um fichário personalizado que processa culture.

As seguintes BindingFlags bandeiras de filtro podem ser usadas para definir quais os membros a incluir na pesquisa:

• Especifique BindingFlags.Public incluir membros públicos na pesquisa.

• Especifique BindingFlags.NonPublic incluir membros não públicos (ou seja, privados, internos e protegidos) na busca.

• Especifique BindingFlags.FlattenHierarchy incluir membros estáticos na hierarquia.

Os seguintes BindingFlags sinalizadores modificadores podem ser usados para alterar o funcionamento da pesquisa:

• BindingFlags.IgnoreCase ignorar o caso de name.

• BindingFlags.DeclaredOnly para procurar apenas os membros declarados no Type, não os membros que foram simplesmente herdados.

As seguintes BindingFlags bandeiras de invocação podem ser usadas para indicar que ação tomar com o membro:

• CreateInstance invocar um construtor. name é ignorado. Não é válido com outras bandeiras de invocação.

• InvokeMethod invocar um método, mas não um construtor ou inicializador de tipos. Não válido com SetField ou SetProperty. Se InvokeMethod for especificado por si próprio, BindingFlags.Public, BindingFlags.Instance, e BindingFlags.Static são automaticamente incluídos.

• 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 adquirir uma propriedade. Não é válido com SetProperty.

• SetProperty para estabelecer 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 do método é igual ao número de argumentos no args array (a menos que os argumentos padrão estejam definidos no membro e BindingFlags.OptionalParamBinding estejam especificados).

• O tipo de cada argumento pode ser convertido pelo ligador para o tipo do parâmetro.

O binder vai encontrar todos os métodos de correspondência. Estes métodos são encontrados com base no tipo de ligação requerida (BindingFlags valores InvokeMethod, GetProperty, e assim sucessivamente). O conjunto de métodos é filtrado pelo nome, número de argumentos e um conjunto de modificadores de pesquisa definidos no binder.

Depois de selecionado o método, é invocado. A acessibilidade é verificada nesse ponto. A pesquisa pode controlar que 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 dossier 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 acedidos e invocados através de Reflection sempre que o código for totalmente confiável.

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

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

Se F for a String[], pode usar código como:

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

que inicializará o campo F nesta nova matriz. Também pode usar Type.InvokeMember para definir uma posição num array fornecendo o índice do valor e depois o valor seguinte, usando código como o seguinte:

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

Isto altera a sequência "z" no array que F mantém para a cadeia "b".

Quando invoca um IDispatch membro, pode especificar o DispID em vez do nome do membro, usando o formato de string "[DispID=##]". Por exemplo, se o DispID do MyComMethod for 3, pode especificar a cadeia "[DispID=3]" em vez de "MyComMethod". Invocar um membro por DispID é mais rápido do que procurar o membro pelo nome. Em cenários complexos de agregação, o DispID é por vezes a única forma de invocar o membro desejado.

Ver também

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

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

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

member 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

Devoluções

Um objeto que representa o valor de retorno do membro invocado.

Implementações

Exceções

Exemplos

O exemplo seguinte é usado InvokeMember para aceder a membros de um tipo.

using System;
using System.Reflection;

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

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

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

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

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

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

Observações

As seguintes BindingFlags bandeiras de filtro podem ser usadas para definir quais os membros a incluir na pesquisa:

• Especifique BindingFlags.Public incluir membros públicos na pesquisa.

• Especifique BindingFlags.NonPublic incluir membros não públicos (ou seja, membros privados e protegidos) na pesquisa.

• Especifique BindingFlags.FlattenHierarchy incluir membros estáticos na hierarquia.

Os seguintes BindingFlags sinalizadores modificadores podem ser usados para alterar o funcionamento da pesquisa:

• BindingFlags.IgnoreCase ignorar o caso de name.

• BindingFlags.DeclaredOnly para procurar apenas os membros declarados no Type, não os membros que foram simplesmente herdados.

As seguintes BindingFlags bandeiras de invocação podem ser usadas para indicar que ação tomar com o membro:

• CreateInstance invocar um construtor. name é ignorado. Não é válido com outras bandeiras de invocação.

• InvokeMethod invocar um método, mas não um construtor ou inicializador de tipos. Não válido com SetField ou SetProperty. Se InvokeMethod for especificado por si próprio, BindingFlags.Public, BindingFlags.Instance, e BindingFlags.Static são automaticamente incluídos.

• 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 adquirir uma propriedade. Não é válido com SetProperty.

• SetProperty para estabelecer 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 do método é igual ao número de argumentos no args array (a menos que os argumentos padrão estejam definidos no membro e BindingFlags.OptionalParamBinding estejam especificados).

• O tipo de cada argumento pode ser convertido pelo ligador para o tipo do parâmetro.

O binder vai encontrar todos os métodos de correspondência. Estes métodos são encontrados com base no tipo de ligação requerida (BindingFlags valores InvokeMethod, GetProperty, e assim sucessivamente). O conjunto de métodos é filtrado pelo nome, número de argumentos e um conjunto de modificadores de pesquisa definidos no binder.

Depois de selecionado o método, é invocado. A acessibilidade é verificada nesse ponto. A pesquisa pode controlar que 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 dossier 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 acedidos e invocados sempre System.Reflection que o código for totalmente confiável.

Pode usar Type.InvokeMember para definir um campo com um valor específico especificando BindingFlags.SetField. Por exemplo, se quiseres definir um campo de instância pública chamado F na classe C, e F é um String, podes usar código como:

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

Se F for a String[], pode 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 nesta nova matriz. Também pode usar Type.InvokeMember para definir uma posição num array fornecendo o índice do valor e depois o valor seguinte, usando código como o seguinte:

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

Isto altera a sequência "z" no array que F mantém para a cadeia "b".

Quando invoca um IDispatch membro, pode especificar o DispID em vez do nome do membro, usando o formato string "[DispID=##]". Por exemplo, se o DispID do MyComMethod for 3, pode especificar a cadeia "[DispID=3]" em vez de "MyComMethod". Invocar um membro por DispID é mais rápido do que procurar o membro pelo nome. Em cenários complexos de agregação, o DispID é por vezes a única forma de invocar o membro desejado.

Ver também

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