DynamicMethod.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo) Méthode

Définition

Appelle la méthode dynamique à l’aide des paramètres spécifiés, sous les contraintes du binder spécifié, avec les informations de culture spécifiées.Invokes the dynamic method using the specified parameters, under the constraints of the specified binder, with the specified culture information.

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

Paramètres

obj
Object

Ce paramètre est ignoré pour les méthodes dynamiques, car elles sont statiques.This parameter is ignored for dynamic methods, because they are static. Spécifiez null.Specify null.

invokeAttr
BindingFlags

Combinaison de bits de valeurs BindingFlags.A bitwise combination of BindingFlags values.

binder
Binder

Objet Binder qui active la liaison, la contrainte de types d’arguments, l’appel des membres et la récupération d’objets MemberInfo par la réflexion.A Binder object that enables the binding, coercion of argument types, invocation of members, and retrieval of MemberInfo objects through reflection. Si binder est null, le binder par défaut est utilisé.If binder is null, the default binder is used. Pour plus d'informations, consultez Binder.For more details, see Binder.

parameters
Object[]

Liste d’arguments.An argument list. Il s’agit d’un tableau d’arguments possédant les mêmes nombre, ordre et type que les paramètres de la méthode à appeler.This is an array of arguments with the same number, order, and type as the parameters of the method to be invoked. En l’absence de paramètres, ce paramètre doit avoir la valeur null.If there are no parameters this parameter should be null.

culture
CultureInfo

Instance de CultureInfo utilisée pour régir la contrainte des types.An instance of CultureInfo used to govern the coercion of types. Si la valeur est null, le CultureInfo du thread actuel est utilisé.If this is null, the CultureInfo for the current thread is used. Par exemple, ces informations sont nécessaires pour convertir correctement un String représentant 1000 en valeur Double, car 1000 est représenté de différentes manières selon la culture.For example, this information is needed to correctly convert a String that represents 1000 to a Double value, because 1000 is represented differently by different cultures.

Retours

Object contenant la valeur de retour de la méthode appelée.A Object containing the return value of the invoked method.

Exceptions

La convention d’appel VarArgs n’est pas prise en charge.The VarArgs calling convention is not supported.

Le nombre d’éléments dans parameters ne correspond pas au nombre de paramètres dans la méthode dynamique.The number of elements in parameters does not match the number of parameters in the dynamic method.

Le type d’un ou plusieurs éléments de parameters ne correspond pas au type du paramètre correspondant de la méthode dynamique.The type of one or more elements of parameters does not match the type of the corresponding parameter of the dynamic method.

La méthode dynamique est associée à un module, n’est pas hébergée de manière anonyme, et la valeur false a été affectée à skipVisibility lors de sa construction. Toutefois, la méthode dynamique accède à des membres qui ne sont pas public ou internal (Friend en Visual Basic).The dynamic method is associated with a module, is not anonymously hosted, and was constructed with skipVisibility set to false, but the dynamic method accesses members that are not public or internal (Friend in Visual Basic).

- ou --or- La méthode dynamique est hébergée de manière anonyme, et la valeur false a été affectée à skipVisibility lors de sa construction. Toutefois, elle accède à des membres qui ne sont pas public.The dynamic method is anonymously hosted and was constructed with skipVisibility set to false, but it accesses members that are not public.

- ou --or- La méthode dynamique contient du code non vérifiable.The dynamic method contains unverifiable code. Consultez la section « Vérification » dans la section Notes pour DynamicMethod.See the "Verification" section in Remarks for DynamicMethod.

Exemples

L’exemple de code suivant appelle une méthode dynamique avec une liaison exacte, à l’aide de la culture anglais (États-Unis).The following code example invokes a dynamic method with exact binding, using the US-English culture. Cet exemple de code fait partie d’un exemple plus complet fourni pour la classe DynamicMethod.This code example is part of a larger example provided for the DynamicMethod class.

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)

Remarques

En plus des exceptions listées, le code appelant doit être préparé à intercepter toutes les exceptions levées par la méthode dynamique.In addition to the listed exceptions, the calling code should be prepared to catch any exceptions thrown by the dynamic method.

L’exécution d’une méthode dynamique avec un délégué créé par la méthode CreateDelegate est plus efficace que son exécution avec la méthode Invoke.Executing a dynamic method with a delegate created by the CreateDelegate method is more efficient than executing it with the Invoke method.

L’appel de la méthode Invoke ou de la méthode CreateDelegate termine la méthode dynamique.Calling the Invoke method or the CreateDelegate method completes the dynamic method. Toute tentative supplémentaire de modification de la méthode dynamique, telle que la modification des définitions de paramètres ou l’émission d’un plus grand langage MSIL (Microsoft Intermediate Language), est ignorée. aucune exception n’est levée.Any further attempt to alter the dynamic method, such as modifying parameter definitions or emitting more Microsoft intermediate language (MSIL), is ignored; no exception is thrown.

Toutes les méthodes dynamiques étant statiques, le paramètre obj est toujours ignoré.All dynamic methods are static, so the obj parameter is always ignored. Pour traiter une méthode dynamique comme s’il s’agissait d’une méthode d’instance, utilisez la surcharge CreateDelegate(Type, Object) qui prend une instance d’objet.To treat a dynamic method as if it were an instance method, use the CreateDelegate(Type, Object) overload that takes an object instance.

Si la méthode dynamique n’a pas de paramètres, la valeur de parameters doit être null.If the dynamic method has no parameters, the value of parameters should be null. Sinon, le nombre, le type et l’ordre des éléments dans le tableau de paramètres doivent être identiques au nombre, au type et à l’ordre des paramètres de la méthode dynamique.Otherwise the number, type, and order of elements in the parameters array should be identical to the number, type, and order of parameters of the dynamic method.

Notes

Cette surcharge de méthode est appelée par l' Invoke(Object, Object[]) surcharge de méthode héritée de la classe MethodBase, donc les remarques précédentes s’appliquent aux deux surcharges.This method overload is called by the Invoke(Object, Object[]) method overload inherited from the MethodBase class, so the preceding remarks apply to both overloads.

Cette méthode ne demande pas d’autorisations directement, mais l’appel de la méthode dynamique peut entraîner des demandes de sécurité, en fonction de la méthode.This method does not demand permissions directly, but invoking the dynamic method can result in security demands, depending on the method. Par exemple, aucune demande n’est faite pour les méthodes dynamiques hébergées anonymement qui sont créées avec le paramètre restrictedSkipVisibility défini sur false.For example, no demands are made for anonymously hosted dynamic methods that are created with the restrictedSkipVisibility parameter set to false. En revanche, si vous créez une méthode avec restrictedSkipVisibility défini sur true afin qu’elle puisse accéder à un membre masqué d’un assembly cible, la méthode entraîne une demande pour les autorisations de l’assembly cible plus ReflectionPermission avec l’indicateur ReflectionPermissionFlag.MemberAccess.On the other hand, if you create a method with restrictedSkipVisibility set to true so it can access a hidden member of a target assembly, the method will cause a demand for the permissions of the target assembly plus ReflectionPermission with the ReflectionPermissionFlag.MemberAccess flag.

Notes

Avant le .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, cette méthode nécessitait ReflectionPermission avec l’indicateur MemberAccess.Prior to the .NET Framework 2.0 Service Pack 1.NET Framework 2.0 Service Pack 1, this method required ReflectionPermission with the MemberAccess flag.

S’applique à

Voir aussi