DynamicMethod.Invoke Método

Referencia

Definición

Espacio de nombres:: System.Reflection.Emit

Ensamblado:: System.Reflection.Emit.Lightweight.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Invoca el método dinámico usando los parámetros especificados, bajo las restricciones del enlazador especificado, con la información de la referencia cultural especificada.

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

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

Este parámetro se omite para los métodos dinámicos porque son estáticos. Especifique null.

invokeAttr: BindingFlags

Combinación bit a bit de valores BindingFlags.

binder: Binder

Objeto Binder que permite el enlace, la conversión de tipos de argumentos, la llamada de miembros y la recuperación de objetos MemberInfo mediante reflexión. Si binder es null, se usa el enlazador predeterminado. Para obtener más información, vea Binder.

parameters: Object[]

Lista de argumentos. Esta es una matriz de argumentos con el mismo número, orden y tipo que los parámetros del método al que se va a invocar. Si no hay parámetros, este parámetro debe ser null.

culture: CultureInfo

Instancia de CultureInfo usada para regir la conversión de tipos. Si es null, se utiliza CultureInfo para el subproceso actual. Por ejemplo, esta información es necesaria para convertir un tipo String que representa 1000 en un valor Double, porque 1000 se representa de maneras diferentes según la referencia cultural.

Devoluciones

Object

Object que contiene el valor devuelto por el método invocado.

Excepciones

NotSupportedException

No se admite la convención de llamada VarArgs.

TargetParameterCountException

El número de parámetros de parameters no coincide con el número de parámetros del método dinámico.

ArgumentException

El tipo de uno o varios elementos de parameters no coincide con el tipo del parámetro correspondiente del método dinámico.

TargetInvocationException

El método dinámico está asociado a un módulo, no está hospedado de forma anónima y se construyó con skipVisibility establecido en false, pero el método dinámico tiene acceso a miembros que no son public o internal (Friend en Visual Basic).

o bien El método dinámico se hospeda de forma anónima y se construyó con skipVisibility establecido en false, pero tiene acceso a miembros que no son public.

o bien El método dinámico contiene código no comprobable. Vea la sección "Comprobación" en Comentarios para DynamicMethod.

Ejemplos

En el ejemplo de código siguiente se invoca un método dinámico con enlace exacto, mediante la referencia cultural US-English. Este ejemplo de código es parte de un ejemplo mayor proporcionado para la clase DynamicMethod.

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)

Comentarios

Además de las excepciones enumeradas, el código de llamada debe estar preparado para detectar las excepciones producidas por el método dinámico.

Ejecutar un método dinámico con un delegado creado por el CreateDelegate método es más eficaz que ejecutarlo con el Invoke método .

Al llamar al Invoke método o al CreateDelegate método se completa el método dinámico. Cualquier intento adicional de modificar el método dinámico, como modificar definiciones de parámetros o emitir más lenguaje intermedio de Microsoft (MSIL), se omite; no se produce ninguna excepción.

Todos los métodos dinámicos son estáticos, por lo que el obj parámetro siempre se omite. Para tratar un método dinámico como si fuera un método de instancia, use la CreateDelegate(Type, Object) sobrecarga que toma una instancia de objeto.

Si el método dinámico no tiene parámetros, el valor de parameters debe ser null. De lo contrario, el número, el tipo y el orden de los elementos de la matriz de parámetros deben ser idénticos al número, el tipo y el orden de los parámetros del método dinámico.

Nota

La sobrecarga de método hereda de la MethodBase clase llama Invoke(Object, Object[]) a esta sobrecarga de método, por lo que las observaciones anteriores se aplican a ambas sobrecargas.

Este método no exige permisos directamente, pero invocar el método dinámico puede dar lugar a demandas de seguridad, en función del método. Por ejemplo, no se exigen métodos dinámicos hospedados de forma anónima que se crean con el restrictedSkipVisibility parámetro establecido falseen . Por otro lado, si crea un método con restrictedSkipVisibility establecido en true para que pueda acceder a un miembro oculto de un ensamblado de destino, el método provocará una demanda de permisos del ensamblado de destino más ReflectionPermission con la ReflectionPermissionFlag.MemberAccess marca .