Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais
Cette documentation est archivée et n’est pas conservée.

DynamicMethod, classe

Définit et représente une méthode dynamique qui peut être compilée, exécutée et ignorée. Les méthodes ignorées sont disponibles pour le garbage collection.

Espace de noms :  System.Reflection.Emit
Assembly :  mscorlib (dans mscorlib.dll)

[ComVisibleAttribute(true)]
public sealed class DynamicMethod : MethodInfo

Le type DynamicMethod expose les membres suivants.

  NomDescription
Méthode publiqueDynamicMethod(String, Type, Type[])Initialise une méthode dynamique hébergée de manière anonyme, en spécifiant le nom de la méthode, le type de retour et les types de paramètre.
Méthode publiqueDynamicMethod(String, Type, Type[], Boolean)Initialise une méthode dynamique hébergée de manière anonyme, en spécifiant le nom de la méthode, le type de retour, les types de paramètre, et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage MSIL de la méthode dynamique.
Méthode publiqueDynamicMethod(String, Type, Type[], Module)Crée une méthode dynamique qui est globale pour un module, en spécifiant le nom de la méthode, le type de retour, les types de paramètres et le module.
Méthode publiqueDynamicMethod(String, Type, Type[], Type)Crée une méthode dynamique, en spécifiant le nom de la méthode, le type de retour, les types de paramètres et le type auquel la méthode dynamique est associée de manière logique.
Méthode publiqueDynamicMethod(String, Type, Type[], Module, Boolean)Crée une méthode dynamique qui est globale pour un module, en spécifiant le nom de la méthode, le type de retour, les types de paramètres, le module et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage Microsoft Intermediate Language (MSIL) de la méthode dynamique.
Méthode publiqueDynamicMethod(String, Type, Type[], Type, Boolean)Crée une méthode dynamique, en spécifiant le nom de la méthode, le type de retour, les types de paramètres, le type auquel la méthode dynamique est associée de manière logique, et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage MSIL de la méthode dynamique.
Méthode publiqueDynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Module, Boolean)Crée une méthode dynamique qui est globale pour un module, en spécifiant le nom de la méthode, les attributs, les conventions d'appel, le type de retour, les types de paramètres, le module et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage Microsoft Intermediate Language (MSIL) de la méthode dynamique.
Méthode publiqueDynamicMethod(String, MethodAttributes, CallingConventions, Type, Type[], Type, Boolean)Crée une méthode dynamique, en spécifiant le nom de la méthode, les attributs, la convention d'appel, le type de retour, les types de paramètres, le type auquel la méthode dynamique est associée de manière logique, et si les contrôles de visibilité juste-à-temps (JIT) doivent être ignorés pour les types et membres auxquels accède le langage MSIL de la méthode dynamique.
Début

  NomDescription
Propriété publiqueAttributesObtient les attributs spécifiés au moment de la création de la méthode dynamique. (Substitue MethodBase.Attributes.)
Propriété publiqueCallingConventionObtient la convention d'appel spécifiée au moment de la création de la méthode dynamique. (Substitue MethodBase.CallingConvention.)
Propriété publiqueContainsGenericParametersObtient une valeur indiquant si la méthode générique contient des paramètres de type générique non assignés. (Hérité de MethodBase.)
Propriété publiqueDeclaringTypeObtient le type qui déclare la méthode (toujours null pour les méthodes dynamiques). (Substitue MemberInfo.DeclaringType.)
Propriété publiqueInitLocalsObtient ou définit une valeur qui indique si les variables locales contenues dans la méthode sont initialisées à zéro.
Propriété publiqueIsAbstractObtient une valeur indiquant si la méthode est abstraite. (Hérité de MethodBase.)
Propriété publiqueIsAssemblyObtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par MethodAttributes.Assembly, c'est-à-dire si la méthode ou le constructeur est visible au maximum par d'autres types du même assembly, et n'est pas visible par des types dérivés à l'extérieur de l'assembly. (Hérité de MethodBase.)
Propriété publiqueIsConstructorObtient une valeur indiquant si la méthode est un constructeur. (Hérité de MethodBase.)
Propriété publiqueIsFamilyObtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par MethodAttributes.Family, c'est-à-dire si la méthode ou le constructeur est visible uniquement dans sa classe et dans ses classes dérivées. (Hérité de MethodBase.)
Propriété publiqueIsFamilyAndAssemblyObtient une valeur indiquant si la visibilité de cette méthode ou de ce constructeur est décrite par MethodAttributes.FamANDAssem, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées, mais uniquement si elles se trouvent dans le même assembly. (Hérité de MethodBase.)
Propriété publiqueIsFamilyOrAssemblyObtient une valeur indiquant si la visibilité potentielle de cette méthode ou de ce constructeur est décrite par MethodAttributes.FamORAssem, c'est-à-dire si la méthode ou le constructeur peut être appelé par des classes dérivées où qu'elles se trouvent, et par des classes du même assembly. (Hérité de MethodBase.)
Propriété publiqueIsFinalObtient une valeur indiquant si cette méthode est final. (Hérité de MethodBase.)
Propriété publiqueIsGenericMethodObtient une valeur indiquant si la méthode est générique. (Hérité de MethodBase.)
Propriété publiqueIsGenericMethodDefinitionObtient une valeur indiquant si la méthode est une définition de méthode générique. (Hérité de MethodBase.)
Propriété publiqueIsHideBySigObtient une valeur indiquant si seul un membre du même type, doté d'une signature identique, est caché dans la classe dérivée. (Hérité de MethodBase.)
Propriété publiqueIsPrivateObtient une valeur indiquant si ce membre est privé. (Hérité de MethodBase.)
Propriété publiqueIsPublicObtient une valeur indiquant s'il s'agit d'une méthode publique. (Hérité de MethodBase.)
Propriété publiqueIsSecurityCriticalObtient une valeur qui indique si la méthode dynamique actuelle est critique de sécurité (security-critical) ou critique sécurisée (security-safe-critical) et peut par conséquent exécuter des opérations critiques. (Substitue MethodBase.IsSecurityCritical.)
Propriété publiqueIsSecuritySafeCriticalObtient une valeur qui indique si la méthode dynamique actuelle est critique sécurisée au niveau de confiance actuel ; autrement dit, si elle peut exécuter des opérations critiques et être accessible par du code transparent. (Substitue MethodBase.IsSecuritySafeCritical.)
Propriété publiqueIsSecurityTransparentObtient une valeur qui indique si la méthode dynamique actuelle est transparente au niveau de confiance actuel et ne peut par conséquent pas exécuter d'opérations critiques. (Substitue MethodBase.IsSecurityTransparent.)
Propriété publiqueIsSpecialNameObtient une valeur indiquant si cette méthode est dotée d'un nom spécial. (Hérité de MethodBase.)
Propriété publiqueIsStaticObtient une valeur indiquant si la méthode est static. (Hérité de MethodBase.)
Propriété publiqueIsVirtualObtient une valeur indiquant si la méthode est virtual. (Hérité de MethodBase.)
Propriété publiqueMemberTypeObtient une MemberTypes valeur indiquant que ce membre est une méthode. (Hérité de MethodInfo.)
Propriété publiqueMetadataTokenObtient une valeur qui identifie un élément de métadonnées. (Hérité de MemberInfo.)
Propriété publiqueMethodHandleNon pris en charge pour les méthodes dynamiques. (Substitue MethodBase.MethodHandle.)
Propriété publiqueModuleObtient le module auquel la méthode dynamique est associée de manière logique. (Substitue MemberInfo.Module.)
Propriété publiqueNameObtient le nom de la méthode dynamique. (Substitue MemberInfo.Name.)
Propriété publiqueReflectedTypeObtient la classe qui a été utilisée lors d'une réflexion pour obtenir cette méthode. (Substitue MemberInfo.ReflectedType.)
Propriété publiqueReturnParameterObtient le paramètre de retour de la méthode dynamique. (Substitue MethodInfo.ReturnParameter.)
Propriété publiqueReturnTypeObtient le type de la valeur de retour pour la méthode dynamique. (Substitue MethodInfo.ReturnType.)
Propriété publiqueReturnTypeCustomAttributesObtient les attributs personnalisés du type de retour de la méthode dynamique. (Substitue MethodInfo.ReturnTypeCustomAttributes.)
Début

  NomDescription
Méthode publiqueCreateDelegate(Type)Exécute la méthode dynamique et crée un délégué qui peut être utilisé pour l'exécuter.
Méthode publiqueCreateDelegate(Type, Object)Exécute la méthode dynamique et crée un délégué qui peut être utilisé pour l'exécuter, en spécifiant le type délégué et un objet auquel le délégué est lié.
Méthode publiqueDefineParameterDéfinit un paramètre de la méthode dynamique.
Méthode publiqueEqualsRetourne une valeur indiquant si cette instance équivaut à un objet spécifié. (Hérité de MethodInfo.)
Méthode protégéeFinalize Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
Méthode publiqueGetBaseDefinitionRetourne l'implémentation de base de la méthode. (Substitue MethodInfo.GetBaseDefinition().)
Méthode publiqueGetCustomAttributes(Boolean)Retourne tous les attributs personnalisés définis pour la méthode. (Substitue MemberInfo.GetCustomAttributes(Boolean).)
Méthode publiqueGetCustomAttributes(Type, Boolean)Retourne les attributs personnalisés du type spécifié qui a été appliqué à la méthode. (Substitue MemberInfo.GetCustomAttributes(Type, Boolean).)
Méthode publiqueGetCustomAttributesDataRetourne une liste d'objets CustomAttributeData représentant des données relatives aux attributs qui ont été appliqués au membre cible. (Hérité de MemberInfo.)
Méthode publiqueGetDynamicILInfoRetourne un objet DynamicILInfo qui peut être utilisé pour générer un corps de méthode à partir de jetons de métadonnées, de portées et de flux MSIL (Microsoft Intermediate Language).
Méthode publiqueGetGenericArgumentsRetourne un tableau d'objets Type qui représentent les arguments de type d'une méthode générique ou les paramètres de type d'une définition de méthode générique. (Hérité de MethodInfo.)
Méthode publiqueGetGenericMethodDefinitionRetourne un objet MethodInfo qui représente une définition de méthode générique à partir de laquelle la méthode actuelle peut être construite. (Hérité de MethodInfo.)
Méthode publiqueGetHashCodeRetourne le code de hachage de cette instance. (Hérité de MethodInfo.)
Méthode publiqueGetILGenerator()Retourne un générateur MSIL (Microsoft Intermediate Language) pour la méthode, avec une taille de flux MSIL par défaut de 64 octets.
Méthode publiqueGetILGenerator(Int32)Retourne un générateur MSIL (Microsoft Intermediate Language) pour la méthode, avec la taille de flux MSIL spécifiée.
Méthode publiqueGetMethodBodyEn cas de substitution dans une classe dérivée, obtient un objet MethodBody qui donne accès au flux MSIL, aux variables locales et aux exceptions pour la méthode actuelle. (Hérité de MethodBase.)
Méthode publiqueGetMethodImplementationFlagsRetourne les indicateurs d'implémentation de la méthode. (Substitue MethodBase.GetMethodImplementationFlags().)
Méthode publiqueGetParametersRetourne les paramètres de la méthode dynamique. (Substitue MethodBase.GetParameters().)
Méthode publiqueGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiqueInvoke(Object, Object[])Appelle la méthode ou le constructeur représentés par l'instance actuelle, à l'aide des paramètres spécifiés. (Hérité de MethodBase.)
Méthode publiqueInvoke(Object, BindingFlags, Binder, Object[], CultureInfo)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 données. (Substitue MethodBase.Invoke(Object, BindingFlags, Binder, Object[], CultureInfo).)
Méthode publiqueIsDefinedIndique si le type d'attribut personnalisé spécifié est défini. (Substitue MemberInfo.IsDefined(Type, Boolean).)
Méthode publiqueMakeGenericMethodSubstitue les éléments d'un tableau de types aux paramètres de type de la définition de méthode générique actuelle et retourne un objet MethodInfo représentant la méthode construite résultante. (Hérité de MethodInfo.)
Méthode protégéeMemberwiseCloneCrée une copie superficielle de l'objet Object actif. (Hérité de Object.)
Méthode publiqueToStringRetourne la signature de la méthode, représentée sous la forme d'une chaîne. (Substitue Object.ToString().)
Début

  NomDescription
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetTypeObtient un objet Type représentant la classe MemberInfo. (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetTypeInfoRécupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface. (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MemberInfo.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de MemberInfo.)
Implémentation d'interface expliciteMéthode privée_MethodBase.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.GetTypePour obtenir une description de ce membre, consultez _MethodBase.GetType. (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.GetTypeInfoRécupère les informations de type pour un objet, qui peuvent être utilisées ensuite pour obtenir les informations de type d'une interface. (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodBase.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsAbstractPour obtenir une description de ce membre, consultez _MethodBase.IsAbstract. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsAssemblyPour obtenir une description de ce membre, consultez _MethodBase.IsAssembly. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsConstructorPour obtenir une description de ce membre, consultez _MethodBase.IsConstructor. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFamilyPour obtenir une description de ce membre, consultez _MethodBase.IsFamily. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFamilyAndAssemblyPour obtenir une description de ce membre, consultez _MethodBase.IsFamilyAndAssembly. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFamilyOrAssemblyPour obtenir une description de ce membre, consultez _MethodBase.IsFamilyOrAssembly. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsFinalPour obtenir une description de ce membre, consultez _MethodBase.IsFinal. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsHideBySigPour obtenir une description de ce membre, consultez _MethodBase.IsHideBySig. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsPrivatePour obtenir une description de ce membre, consultez _MethodBase.IsPrivate. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsPublicPour obtenir une description de ce membre, consultez _MethodBase.IsPublic. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsSpecialNamePour obtenir une description de ce membre, consultez _MethodBase.IsSpecialName. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsStaticPour obtenir une description de ce membre, consultez _MethodBase.IsStatic. (Hérité de MethodBase.)
Implémentation d'interface explicitePropriété privée_MethodBase.IsVirtualPour obtenir une description de ce membre, consultez _MethodBase.IsVirtual. (Hérité de MethodBase.)
Implémentation d'interface expliciteMéthode privée_MethodInfo.GetIDsOfNamesMappe un jeu de noms avec un jeu correspondant d'identificateurs de dispatch. (Hérité de MethodInfo.)
Implémentation d'interface expliciteMéthode privée_MethodInfo.GetTypeFournit l'accès à la méthode GetType à partir de COM. (Hérité de MethodInfo.)
Implémentation d'interface expliciteMéthode privée_MethodInfo.GetTypeInfoRécupère les informations de type pour un objet, qui peuvent être utilisées pour obtenir les informations de type d'une interface. (Hérité de MethodInfo.)
Implémentation d'interface expliciteMéthode privée_MethodInfo.GetTypeInfoCountRécupère le nombre d'interfaces d'informations de type fourni par un objet (0 ou 1). (Hérité de MethodInfo.)
Implémentation d'interface expliciteMéthode privée_MethodInfo.InvokeFournit l'accès aux propriétés et aux méthodes exposées par un objet. (Hérité de MethodInfo.)
Début

Vous pouvez utiliser la classe DynamicMethod pour générer et exécuter une méthode au moment de l'exécution, sans être obligé de générer un assembly dynamique et un type dynamique qui contiendront la méthode. Le code exécutable créé par le compilateur juste-à-temps (JIT) est libéré lorsque l'objet DynamicMethod est récupéré. Les méthodes dynamiques constituent le moyen le plus efficace de générer et d'exécuter de petites quantités de code.

Une méthode dynamique peut être hébergée anonymement, ou elle peut être associée logiquement à un module ou un type.

  • Si la méthode dynamique est hébergée anonymement, elle est placée dans un assembly fourni par le système, et est par conséquent isolée du reste du code. Par défaut, elle n'a pas accès aux données non publiques. Une méthode dynamique hébergée de manière anonyme peut disposer de capacités limitées pour ignorer les contrôles de visibilité du compilateur JIT, si l'autorisation ReflectionPermission lui a été accordée, avec l'indicateur ReflectionPermissionFlag.RestrictedMemberAccess. Le niveau de confiance de l'assembly dont les membres non publics sont accédés par la méthode dynamique doit être égal au niveau de confiance, ou à un sous-ensemble du niveau de confiance, de la pile des appels qui a émis la méthode dynamique. Pour plus d'informations sur les méthodes dynamiques hébergées de manière anonyme, consultez Procédure pas à pas : émission de code dans des scénarios de confiance partielle.

  • Si la méthode dynamique est associée à un module que vous spécifiez, elle est effectivement globale pour ce module. Elle peut accéder à tous les types dans le module et tous les membres internal (Friend dans Visual Basic) de ces types. Vous pouvez associer une méthode dynamique à tout module, que vous ayez ou non créé ce module, pourvu qu'une demande pour ReflectionPermission avec l'indicateur RestrictedMemberAccess puisse être satisfaite par la pile des appels qui contient votre code. Si l'indicateur ReflectionPermissionFlag.MemberAccess est inclus dans les droits octroyés, la méthode dynamique peut ignorer les contrôles de visibilité du compilateur JIT et accéder aux données privées de tous les types déclarées dans le module ou dans tout autre module de tout assembly.

    RemarqueRemarque

    Lorsque vous spécifiez le module auquel une méthode dynamique est associée, ce module ne doit pas être dans l'assembly fourni par le système utilisé pour un hébergement anonyme.

  • Si la méthode dynamique est associée à un type que vous spécifiez, elle a accès à tous les membres du type, quel que soit le niveau d'accès. De plus, les contrôles de visibilité JIT peuvent être ignorés. La méthode dynamique a ainsi accès aux données privées des autres types déclarés dans le même module ou dans tout autre module de tout assembly. Vous pouvez associer une méthode dynamique à n'importe quel type, mais votre code doit se voir octroyer l'autorisation ReflectionPermission avec à la fois les indicateurs RestrictedMemberAccess et MemberAccess.

Le tableau suivant indique les types et membres qui sont accessibles à une méthode dynamique hébergée de manière anonyme, avec et sans contrôles de visibilité JIT, selon que ReflectionPermission est accordé ou non avec l'indicateur RestrictedMemberAccess.

 

Sans RestrictedMemberAccess

Avec RestrictedMemberAccess

Sans ignorer les contrôles de visibilité JIT

Membres publics de types publics dans tout assembly.

Membres publics de types publics dans tout assembly.

En ignorant les contrôles de visibilité JIT, avec restrictions

Membres publics de types publics dans tout assembly.

Tous les membres de tous les types, uniquement dans les assemblys dont les niveaux de confiance sont égaux ou inférieurs au niveau de confiance de l'assembly qui a émis la méthode dynamique.

RemarqueRemarque

Avant .NET Framework version 2.0 Service Pack 1, l'émission du code nécessitait ReflectionPermission avec l'indicateur ReflectionPermissionFlag.ReflectionEmit. Cette autorisation est incluse par défaut dans les jeux d'autorisations FullTrust et LocalIntranet, mais pas dans le jeu d'autorisations Internet. Par conséquent, dans les versions antérieures de .NET Framework, une bibliothèque peut être utilisée avec les autorisations Internet uniquement si celle-ci dispose de l'attribut SecurityCriticalAttribute et si elle exécute également un Assert pour ReflectionEmit. Ces bibliothèques nécessitent une révision de sécurité approfondie car les erreurs de codage pourraient provoquer des failles de sécurité. .NET Framework 2.0 SP1 autorise l'émission de code dans des scénarios de confiance partielle sans émission de demandes de sécurité, parce que la génération du code n'est pas fondamentalement une opération privilégiée. Autrement dit, le code généré n'a pas plus d'autorisations que l'assembly qui l'émet. Cela permet aux bibliothèques qui émettent du code d'être Security Transparent et évite d'avoir à déclarer ReflectionEmit, ce qui simplifie l'écriture d'une bibliothèque sécurisée. Pour utiliser cette fonctionnalité, votre application doit cibler le .NET Framework version 3.5 ou version ultérieure.

Le tableau suivant indique les types et membres qui sont accessibles à une méthode dynamique associée avec un module ou un type dans un module.

 

Associée à un module

Associée à un type

Sans ignorer les contrôles de visibilité JIT

Membres publics et internes de types publics, internes et privés dans le module.

Membres publics de types publics dans tout assembly.

Tous les membres du type associé. Membres publics et internes de tous les autres types dans le module.

Membres publics de types publics dans tout assembly.

En ignorant les contrôles de visibilité JIT

Tous les membres de tous les types dans tout assembly.

Tous les membres de tous les types dans tout assembly.

Une méthode dynamique associée à un module a les autorisations de ce module. Une méthode dynamique associée à un type a les autorisations du module contenant ce type.

Les méthodes dynamiques et leurs paramètres ne doivent pas être nommés, mais vous pouvez spécifier des noms pour vous aider lors du débogage. Les attributs personnalisés ne sont pas pris en charge sur les méthodes dynamiques ou leurs paramètres.

Même si les méthodes dynamiques sont des méthodes static (méthodes Shared en Visual Basic), les règles assouplies pour la liaison de délégués introduites dans le .NET Framework 2.0 autorisent la liaison d'une méthode dynamique à un objet, afin qu'elle agisse comme une méthode d'instance lorsqu'elle est appelée à l'aide de cette instance du délégué. Cela est d'ailleurs illustré dans l'exemple appliqué à la surcharge de la méthode CreateDelegate(Type, Object).

RemarqueRemarque

Dans le .NET Framework 2.0, les méthodes dynamiques ne prennent pas en charge les informations de symbole, autrement dit, les noms de variable locale et le mappage de numéro de ligne. Cette limite pourrait être supprimée dans une prochaine version. Vous pouvez utiliser AssemblyBuilder pendant le développement pour simplifier le débogage du langage intermédiaire Microsoft généré (MSIL), puis basculer sur les méthodes dynamiques pendant le déploiement final, parce que les appels ILGenerator sont identiques dans les deux cas.

Vérification

La liste suivante résume les conditions sous lesquelles les méthodes dynamiques peuvent contenir du code non vérifiable. (Par exemple, une méthode dynamique est incontrôlable si sa propriété InitLocals a la valeur false.)

  • Une méthode dynamique associée à un assembly critique de sécurité est également critique de sécurité et peut ignorer la vérification. Par exemple, un assembly sans attributs de sécurité exécuté comme une application de bureau est traité comme critique de sécurité par le runtime. Si vous associez une méthode dynamique à l'assembly, la méthode dynamique peut contenir du code non vérifiable.

  • Si une méthode dynamique qui contient du code non vérifiable est associée à un assembly dont la transparence est de niveau 1, le compilateur juste-à-temps (JIT) injecte une requête de sécurité. La demande réussit uniquement si la méthode dynamique est exécutée par un code d'un niveau de confiance totale. Consultez Code transparent de sécurité, niveau 1.

  • Si une méthode dynamique qui contient du code non vérifiable est associée à un assembly dont la transparence est de niveau 2 (tel que mscorlib.dll), elle lève une exception (injectée par le compilateur JIT) au lieu d'effectuer une requête de sécurité. Consultez Code transparent de sécurité, niveau 2.

  • Une méthode dynamique hébergée de manière anonyme qui contient le code non vérifiable lève toujours une exception. Elle ne peut jamais ignorer la vérification, même si elle est créée et exécutée par du code d'un niveau de confiance totale.

L'exception levée pour le code non vérifiable varie selon la façon dont la méthode dynamique est appelée. Si vous appelez une méthode dynamique à l'aide d'un délégué retourné par la méthode CreateDelegate, une VerificationException est levée. Si vous appelez la méthode dynamique à l'aide de la méthode Invoke, une TargetInvocationException est levée avec une VerificationException interne.

L'exemple de code suivant crée une méthode dynamique qui prend deux paramètres. Il émet un corps de fonction simple qui imprime le premier paramètre dans la console, et utilise le deuxième paramètre comme valeur de retour de la méthode. L'exemple exécute la méthode en créant un délégué, appelle le délégué avec des paramètres différents, puis appelle la méthode dynamique à l'aide de la méthode Invoke.


using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Globalization;

public class Test
{
    // Declare a delegate type that can be used to execute the completed
    // dynamic method. 
    private delegate int HelloDelegate(string msg, int ret);

    public static void Main()
    {
        // Create an array that specifies the types of the parameters
        // of the dynamic method. This dynamic method has a String
        // parameter and an Integer parameter.
        Type[] helloArgs = {typeof(string), typeof(int)};

        // Create a dynamic method with the name "Hello", a return type
        // of Integer, and two parameters whose types are specified by
        // the array helloArgs. Create the method in the module that
        // defines the String class.
        DynamicMethod hello = new DynamicMethod("Hello", 
            typeof(int), 
            helloArgs, 
            typeof(string).Module);

        // Create an array that specifies the parameter types of the
        // overload of Console.WriteLine to be used in Hello.
        Type[] writeStringArgs = {typeof(string)};
        // Get the overload of Console.WriteLine that has one
        // String parameter.
        MethodInfo writeString = typeof(Console).GetMethod("WriteLine", 
            writeStringArgs);

        // Get an ILGenerator and emit a body for the dynamic method,
        // using a stream size larger than the IL that will be
        // emitted.
        ILGenerator il = hello.GetILGenerator(256);
        // Load the first argument, which is a string, onto the stack.
        il.Emit(OpCodes.Ldarg_0);
        // Call the overload of Console.WriteLine that prints a string.
        il.EmitCall(OpCodes.Call, writeString, null);
        // The Hello method returns the value of the second argument;
        // to do this, load the onto the stack and return.
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(OpCodes.Ret);

        // Add parameter information to the dynamic method. (This is not
        // necessary, but can be useful for debugging.) For each parameter,
        // identified by position, supply the parameter attributes and a 
        // parameter name.
        hello.DefineParameter(1, ParameterAttributes.In, "message");
        hello.DefineParameter(2, ParameterAttributes.In, "valueToReturn");

        // Create a delegate that represents the dynamic method. This
        // action completes the method. Any further attempts to
        // change the method are ignored.
        HelloDelegate hi = 
            (HelloDelegate) hello.CreateDelegate(typeof(HelloDelegate));

        // Use the delegate to execute the dynamic method.
        Console.WriteLine("\r\nUse the delegate to execute the dynamic method:");
        int retval = hi("\r\nHello, World!", 42);
        Console.WriteLine("Invoking delegate hi(\"Hello, World!\", 42) returned: " + retval);

        // Execute it again, with different arguments.
        retval = hi("\r\nHi, Mom!", 5280);
        Console.WriteLine("Invoking delegate hi(\"Hi, Mom!\", 5280) returned: " + retval);

        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("\r\n ----- Display information about the dynamic method -----");
        // Display MethodAttributes for the dynamic method, set when 
        // the dynamic method was created.
        Console.WriteLine("\r\nMethod Attributes: {0}", hello.Attributes);

        // Display the calling convention of the dynamic method, set when the 
        // dynamic method was created.
        Console.WriteLine("\r\nCalling convention: {0}", hello.CallingConvention);

        // Display the declaring type, which is always null for dynamic
        // methods.
        if (hello.DeclaringType == null)
        {
            Console.WriteLine("\r\nDeclaringType is always null for dynamic methods.");
        }
        else
        {
            Console.WriteLine("DeclaringType: {0}", hello.DeclaringType);
        }

        // Display the default value for InitLocals.
        if (hello.InitLocals)
        {
            Console.Write("\r\nThis method contains verifiable code.");
        }
        else
        {
            Console.Write("\r\nThis method contains unverifiable code.");
        }
        Console.WriteLine(" (InitLocals = {0})", hello.InitLocals);

        // Display the module specified when the dynamic method was created.
        Console.WriteLine("\r\nModule: {0}", hello.Module);

        // Display the name specified when the dynamic method was created.
        // Note that the name can be blank.
        Console.WriteLine("\r\nName: {0}", hello.Name);

        // For dynamic methods, the reflected type is always null.
        if (hello.ReflectedType == null)
        {
            Console.WriteLine("\r\nReflectedType is null.");
        }
        else
        {
            Console.WriteLine("\r\nReflectedType: {0}", hello.ReflectedType);
        }

        if (hello.ReturnParameter == null)
        {
            Console.WriteLine("\r\nMethod has no return parameter.");
        }
        else
        {
            Console.WriteLine("\r\nReturn parameter: {0}", hello.ReturnParameter);
        }

        // If the method has no return type, ReturnType is System.Void.
        Console.WriteLine("\r\nReturn type: {0}", hello.ReturnType);

        // ReturnTypeCustomAttributes returns an ICustomeAttributeProvider
        // that can be used to enumerate the custom attributes of the
        // return value. At present, there is no way to set such custom
        // attributes, so the list is empty.
        if (hello.ReturnType == typeof(void))
        {
            Console.WriteLine("The method has no return type.");
        }
        else
        {
            ICustomAttributeProvider caProvider = hello.ReturnTypeCustomAttributes;
            object[] returnAttributes = caProvider.GetCustomAttributes(true);
            if (returnAttributes.Length == 0)
            {
                Console.WriteLine("\r\nThe return type has no custom attributes.");
            }
            else
            {
                Console.WriteLine("\r\nThe return type has the following custom attributes:");
                foreach( object attr in returnAttributes )
                {
                    Console.WriteLine("\t{0}", attr.ToString());
                }
            }
        }

        Console.WriteLine("\r\nToString: {0}", hello.ToString());

        // Display parameter information.
        ParameterInfo[] parameters = hello.GetParameters();
        Console.WriteLine("\r\nParameters: name, type, ParameterAttributes");
        foreach( ParameterInfo p in parameters )
        {
            Console.WriteLine("\t{0}, {1}, {2}", 
                p.Name, p.ParameterType, p.Attributes);
        }
    }
}

/* This code example produces the following output:

Use the delegate to execute the dynamic method:

Hello, World!
Invoking delegate hi("Hello, World!", 42) returned: 42

Hi, Mom!
Invoking delegate hi("Hi, Mom!", 5280) returned: 5280

Use the Invoke method to execute the dynamic method:

Hello, World!
hello.Invoke returned: 42

 ----- Display information about the dynamic method -----

Method Attributes: PrivateScope, Public, Static

Calling convention: Standard

DeclaringType is always null for dynamic methods.

This method contains verifiable code. (InitLocals = True)

Module: CommonLanguageRuntimeLibrary

Name: Hello

ReflectedType is null.

Method has no return parameter.

Return type: System.Int32

The return type has no custom attributes.

ToString: Int32 Hello(System.String, Int32)

Parameters: name, type, ParameterAttributes
        message, System.String, In
        valueToReturn, System.Int32, In
 */


.NET Framework

Pris en charge dans : 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.
Afficher: