DynamicMethod.Invoke Metodo

Definizione

Spazio dei nomi:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.Lightweight.dll

Source:

DynamicMethod.CoreCLR.cs

Richiama il metodo dinamico usando i parametri specificati, con i vincoli del binder specificato e le informazioni sulle impostazioni cultura specificate.

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

Parametri

obj

Object

Questo parametro viene ignorato per i metodi dinamici, in quanto sono statici. Specificare null.

invokeAttr

BindingFlags

Combinazione bit per bit dei valori di BindingFlags.

binder

Binder

Oggetto Binder che consente il binding, la coercizione di tipi di argomento, la chiamata di membri e il recupero di oggetti MemberInfo tramite la reflection. Se binder è null, verrà usato il binder predefinito. Per altri dettagli, vedere Binder.

parameters

Object[]

Elenco di argomenti. Matrice di argomenti con lo stesso numero, ordine e tipo dei parametri del metodo da richiamare. In assenza di parametri, questo parametro deve essere null.

culture

CultureInfo

Istanza di CultureInfo usata per regolare la coercizione dei tipi. Se è null, per il thread corrente verrà usato l'oggetto CultureInfo. Queste informazioni sono necessarie, ad esempio, per convertire in modo corretto un valore String che rappresenta 1000 in un valore Double, perché 1000 viene rappresentato in modo diverso nelle diverse impostazioni cultura.

Restituisce

Object

Oggetto Object che contiene il valore restituito del metodo richiamato.

Eccezioni

NotSupportedException

La convenzione di chiamata VarArgs non è supportata.

TargetParameterCountException

Il numero di elementi in parameters non corrisponde al numero dei parametri nel metodo dinamico.

ArgumentException

Il tipo di uno o più elementi di parameters non corrisponde al tipo del parametro corrispondente del metodo dinamico.

TargetInvocationException

Il metodo dinamico è associato a un modulo, non è ospitato in modo anonimo ed è costruito con skipVisibility impostato su false, ma accede a membri che non sono public o internal (Friend in Visual Basic).

-oppure-

Il metodo dinamico è ospitato in modo anonimo ed è costruito con skipVisibility impostato su false, ma accede a membri che non sono public.

-oppure-

Il metodo dinamico contiene codice non verificabile. Vedere la sezione "Verifica" nelle note per DynamicMethod.

Esempio

Nell'esempio di codice seguente viene richiamato un metodo dinamico con associazione esatta, usando le impostazioni cultura US-English. Questo esempio di codice fa parte di un esempio più grande fornito per la 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)

Commenti

Oltre alle eccezioni elencate, il codice chiamante deve essere preparato per rilevare eventuali eccezioni generate dal metodo dinamico.

L'esecuzione CreateDelegate di un metodo dinamico con un delegato creato dal metodo è più efficiente rispetto all'esecuzione con il Invoke metodo .

La chiamata al metodo o al InvokeCreateDelegate metodo completa il metodo dinamico. Qualsiasi ulteriore tentativo di modificare il metodo dinamico, ad esempio la modifica delle definizioni dei parametri o l'emissione di più Microsoft linguaggio intermedio (MSIL), viene ignorata. Nessuna eccezione viene generata.

Tutti i metodi dinamici sono statici, quindi il obj parametro viene sempre ignorato. Per considerare un metodo dinamico come se fosse un metodo di istanza, usare l'overload che accetta un'istanza CreateDelegate(Type, Object) di un oggetto.

Se il metodo dinamico non ha parametri, il valore di parameters deve essere null. In caso contrario, il numero, il tipo e l'ordine degli elementi nella matrice di parametri devono essere identici al numero, al tipo e all'ordine dei parametri del metodo dinamico.

Nota

Questo overload del metodo viene chiamato dall'overload Invoke(Object, Object[])MethodBase del metodo ereditato dalla classe, quindi le osservazioni precedenti si applicano a entrambi gli overload.

Questo metodo non richiede direttamente le autorizzazioni, ma richiamando il metodo dinamico può causare richieste di sicurezza, a seconda del metodo. Ad esempio, nessuna richiesta viene effettuata per i metodi dinamici ospitati in modo anonimo creati con il restrictedSkipVisibility parametro impostato su false. D'altra parte, se si crea un metodo con restrictedSkipVisibility impostato su in modo che possa accedere a true un membro nascosto di un assembly di destinazione, il metodo causerà una richiesta per le autorizzazioni dell'assembly di destinazione più ReflectionPermission con il ReflectionPermissionFlag.MemberAccess flag.

Nota

Prima di .NET Framework 2.0, questo metodo è necessario ReflectionPermission con il MemberAccess flag.

Vedi anche

• CreateDelegate(Type)