DynamicMethod.Invoke Método

Definição

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.Lightweight.dll

Origem:

DynamicMethod.CoreCLR.cs

Invoca o método dinâmico usando os parâmetros especificados, sob as restrições do associador especificado e com as informações de cultura especificadas.

public:
 override System::Object ^ Invoke(System::Object ^ obj, System::Reflection::BindingFlags invokeAttr, System::Reflection::Binder ^ binder, cli::array <System::Object ^> ^ parameters, System::Globalization::CultureInfo ^ culture);

public override object? Invoke (object? obj, System.Reflection.BindingFlags invokeAttr, System.Reflection.Binder? binder, object?[]? parameters, System.Globalization.CultureInfo? culture);

override this.Invoke : obj * System.Reflection.BindingFlags * System.Reflection.Binder * obj[] * System.Globalization.CultureInfo -> obj

Public Overrides Function Invoke (obj As Object, invokeAttr As BindingFlags, binder As Binder, parameters As Object(), culture As CultureInfo) As Object

Parâmetros

obj

Object

Esse parâmetro é ignorado para métodos dinâmicos, pois é estático. Especifique null.

invokeAttr

BindingFlags

Uma combinação bit a bit dos valores BindingFlags.

binder

Binder

Um objeto Binder que permite a associação, coerção de tipos de argumento, invocação de membros e recuperação de objetos MemberInfo por meio da reflexão. Caso binder seja null, o associador padrão é usado. Para obter mais detalhes, confira Binder.

parameters

Object[]

Uma lista de argumentos. Essa é uma matriz de argumentos com o mesmo número, ordem e tipo que os parâmetros do método a ser invocado. Se não houver nenhum parâmetro, esse parâmetro deverá ser null.

culture

CultureInfo

Uma instância de CultureInfo usada para determinar a coerção de tipos. Se isso for null, será usado o CultureInfo para o thread atual. Por exemplo, essas informações são necessárias para converter corretamente um String que representa 1000 em um valor Double, pois 1000 é representado de forma diferente por diferentes culturas.

Retornos

Object

Um Object que contém o valor retornado do método invocado.

Exceções

NotSupportedException

Não há suporte para a convenção de chamada VarArgs.

TargetParameterCountException

O número de elementos em parameters não corresponde ao número de parâmetros no método dinâmico.

ArgumentException

O tipo de um ou mais elementos de parameters não corresponde ao tipo do parâmetro correspondente do método dinâmico.

TargetInvocationException

O método dinâmico está associado a um módulo, não é hospedado anonimamente e foi construído com skipVisibility definido como false, mas acessa membros que não são public nem internal (Friend no Visual Basic).

- ou -

O método dinâmico é hospedado anonimamente e foi construído com skipVisibility definido como false, mas acessa membros que não são public.

- ou -

O método dinâmico contém um código não verificável. Consulte a seção “Verificação” em Comentários de DynamicMethod.

Exemplos

O exemplo de código a seguir invoca um método dinâmico com associação exata, usando a cultura US-English. Este exemplo de código faz parte de um exemplo maior fornecido para a DynamicMethod classe .

Console::WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
// Create an array of arguments to use with the Invoke method.
array<Object^>^ invokeArgs = { "\r\nHello, World!", 42 };
// Invoke the dynamic method using the arguments. This is much
// slower than using the delegate, because you must create an
// array to contain the arguments, and value-type arguments
// must be boxed.
Object^ objRet = hello->Invoke(nullptr, BindingFlags::ExactBinding, nullptr, invokeArgs, gcnew CultureInfo("en-us"));
Console::WriteLine("hello.Invoke returned: " + objRet);

Console.WriteLine("\r\nUse the Invoke method to execute the dynamic method:");
// Create an array of arguments to use with the Invoke method.
object[] invokeArgs = {"\r\nHello, World!", 42};
// Invoke the dynamic method using the arguments. This is much
// slower than using the delegate, because you must create an
// array to contain the arguments, and value-type arguments
// must be boxed.
object objRet = hello.Invoke(null, BindingFlags.ExactBinding, null, invokeArgs, new CultureInfo("en-us"));
Console.WriteLine("hello.Invoke returned: " + objRet);

Console.WriteLine(vbCrLf & "Use the Invoke method to execute the dynamic method:")
' Create an array of arguments to use with the Invoke method.
Dim invokeArgs() As Object = {vbCrLf & "Hello, World!", 42}
' Invoke the dynamic method using the arguments. This is much
' slower than using the delegate, because you must create an
' array to contain the arguments, and value-type arguments
' must be boxed.
Dim objRet As Object = hello.Invoke(Nothing, _
    BindingFlags.ExactBinding, Nothing, invokeArgs, _
    New CultureInfo("en-us"))
Console.WriteLine("hello.Invoke returned: {0}", objRet)

Comentários

Além das exceções listadas, o código de chamada deve estar preparado para capturar quaisquer exceções geradas pelo método dinâmico.

Executar um método dinâmico com um delegado criado pelo CreateDelegate método é mais eficiente do que executá-lo com o Invoke método .

Chamar o Invoke método ou o CreateDelegate método conclui o método dinâmico. Qualquer outra tentativa de alterar o método dinâmico, como modificar definições de parâmetro ou emitir mais MSIL (linguagem intermediária da Microsoft), é ignorada; nenhuma exceção é gerada.

Todos os métodos dinâmicos são estáticos, portanto, o obj parâmetro é sempre ignorado. Para tratar um método dinâmico como se fosse um método de instância, use a CreateDelegate(Type, Object) sobrecarga que usa uma instância de objeto.

Se o método dinâmico não tiver parâmetros, o valor de parameters deverá ser null. Caso contrário, o número, o tipo e a ordem dos elementos na matriz de parâmetros devem ser idênticos ao número, ao tipo e à ordem dos parâmetros do método dinâmico.

Observação

Essa sobrecarga de método é chamada pela sobrecarga de Invoke(Object, Object[]) método herdada da MethodBase classe , portanto, as observações anteriores se aplicam a ambas as sobrecargas.

Esse método não exige permissões diretamente, mas invocar o método dinâmico pode resultar em demandas de segurança, dependendo do método . Por exemplo, nenhuma demanda é feita para métodos dinâmicos hospedados anonimamente que são criados com o restrictedSkipVisibility parâmetro definido falsecomo . Por outro lado, se você criar um método com definido como restrictedSkipVisibility para true que ele possa acessar um membro oculto de um assembly de destino, o método causará uma demanda pelas permissões do assembly de destino mais ReflectionPermission com o ReflectionPermissionFlag.MemberAccess sinalizador.

Observação

Antes do .NET Framework 2.0, esse método era necessário ReflectionPermission com o MemberAccess sinalizador.

Confira também

• CreateDelegate(Type)