Scénarios de méthodes dynamiques avec émission de réflexion
Mise à jour : novembre 2007
Les méthodes dynamiques créées à l'aide de la classe DynamicMethod (nouvelle dans le .NET Framework version 2.0) fournissent des fonctionnalités améliorées permettant d'émettre des méthodes statiques au moment de l'exécution. Les méthodes dynamiques étendent les fonctionnalités des types dans l'espace de noms System.Reflection.Emit de différentes façons :
La charge est moindre, car il n'est pas nécessaire de générer des types, modules et assemblys dynamiques pour contenir les méthodes.
Dans les applications à durée d'exécution longue, elles garantissent une meilleure utilisation des ressources, car la mémoire utilisée par le corps des méthodes peut être libérée lorsque la méthode n'est plus nécessaire.
Avec des autorisations de sécurité suffisantes, elles permettent d'associer du code à un assembly ou à un type existant, et ce code peut avoir la même visibilité que les types internes ou les membres privés.
Avec des autorisations de sécurité suffisantes, elles permettent au code d'ignorer les vérifications de visibilité JIT (juste-à-temps) et d'accéder aux données privées et protégées d'objets.
Les méthodes dynamiques peuvent utiliser un objet ILGenerator pour émettre du code MSIL (Microsoft Intermediate Language). De plus, elles peuvent utiliser un objet DynamicILInfo pour manipuler les portées et les jetons de métadonnées qui permettent à des clients élaborés d'effectuer leur propre génération de code MSIL.
Les méthodes dynamiques sont utiles dans les scénarios où la génération de code au moment de l'exécution est requise pour des raisons de performances. Les exemples présentés dans cette section incluent la sérialisation, les mappages entre des objets et des bases de données relationnelles, les expressions régulières, l'évaluation partielle et les compilateurs pour les langages qui nécessitent un runtime.
Pour obtenir un exemple simple de génération de méthode dynamique, consultez Comment : définir et exécuter des méthodes dynamiques.
Langages qui prennent en charge les appels à liaison tardive
Les méthodes dynamiques sont utiles aux rédacteurs de compilateur lorsque le type d'un objet n'est pas connu au moment de la compilation. Les appels aux membres de l'objet doivent être résolus au moment de l'exécution, et engendrent souvent une charge supplémentaire liée à la manipulation de listes d'arguments. Le code Visual Basic suivant en montre un exemple.
Sub Example(ByVal obj as Object)
' ...
obj.SomeMethod(x, y, z)
' ...
End Sub
Le compilateur doit générer du code pour rechercher SomeMethod, préparer les arguments comme un tableau d'objets, puis appeler la méthode. L'exécution de tels appels avec la réflexion, à l'aide de la méthode InvokeMember, est peu intéressante en termes de performances. Il est possible d'améliorer les performances en utilisant des membres de l'espace de noms System.Reflection.Emit pour créer un assembly, un module, un type et une méthode dynamiques, mais cela peut se traduire par un jeu de travail plus volumineux et un code plus complexe. Les méthodes dynamiques permettent une stratégie d'implémentation plus efficace dans les cas où la signature de la méthode dynamique correspond à un type de délégué existant, parce qu'il n'est pas nécessaire de créer un assembly, module ou type dynamique. Cette approche est bien plus performante que l'utilisation de la méthode InvokeMember. Elle ne l'est pas autant qu'un appel virtuel, mais elle demande un jeu de travail beaucoup plus petit dans la mesure où aucun nouveau type n'est créé. En outre, le code MSIL généré et le code natif associé peuvent être libérés lorsqu'ils sont devenus inutiles.
Sérialisation
Les méthodes dynamiques peuvent supprimer la nécessité d'écrire du code de sérialisation et de désérialisation personnalisé. Vous pouvez marquer un type sérialisable d'après des règles simples, puis utiliser un moteur de sérialisation pour examiner les métadonnées pour le type, générer un sérialiseur et un désérialiseur appropriés en fonction des besoins, et exécuter le code généré sur des instances du type.
Avec des autorisations de sécurité suffisantes, un moteur de sérialisation implémenté à l'aide de méthodes dynamiques peut accéder aux données privées et protégées pour permettre la sérialisation d'objets qui ne sont pas créés par le créateur du moteur.
Les méthodes générées peuvent être mises en cache si elles sont souvent utilisées, ou elles peuvent être simplement libérées.
Évaluation partielle
L'évaluation partielle, également désignée par le terme « spécialisation de programme », est une technique visant à optimiser des algorithmes dans lesquels une ou plusieurs des variables d'entrée varient plus lentement que les autres entrées. L'évaluation partielle génère des appels de méthode spécialisés qui traitent les valeurs des entrées qui varient lentement comme si elles étaient constantes, ce qui permet d'appliquer des optimisations supplémentaires à l'ensemble de l'algorithme.
À l'aide de cette technique, il est souvent possible de transformer un algorithme à usage général peu performant en un algorithme spécialisé très performant. En voici quelques exemples :
Compilation d'un objet Regex pour générer un programme spécialisé pour rechercher des correspondances à un modèle particulier.
Compilation d'un moteur de sérialisation piloté par des métadonnées en un programme spécialisé pour sérialiser et désérialiser un type ou ensemble de types spécifique.
Compilation d'un schéma XML pour générer un programme spécialisé pour valider un schéma particulier.
Compilation d'une transformation XSLT en un programme spécialisé pour transformer un document XML de façon spécifique.
Compilation d'un programme de chiffrement générique qui chiffre des données à l'aide de toute clé spécifiée en un programme optimisé pour une clé particulière.
Les méthodes dynamiques peuvent être utilisées pour implémenter l'évaluation partielle en générant des méthodes spécialisées au moment de l'exécution. En plus de performances améliorées, les méthodes dynamiques permettent de récupérer les corps des méthodes MSIL et le code machine associé généré par le compilateur JIT. Cela peut s'avérer essentiel dans les programmes à période d'activité longue.
Pour une description plus détaillée de certains de ces scénarios, consultez Scénarios d'applications d'émission de réflexion.
Génération de code utilisateur personnalisé au moment de l'exécution
De nombreuses applications ou plates-formes possèdent des mécanismes d'extensibilité qui offrent aux utilisateurs la possibilité d'écrire et d'exécuter du code personnalisé pendant l'exécution de l'application, souvent à l'aide de fonctions prédéfinies. En utilisant des méthodes dynamiques pour générer ce code, le Concepteur d'applications et de plates-formes peut réduire le nombre de fonctions requises (et donc l'encombrement en mémoire) et offrir davantage de souplesse à l'utilisateur sans nuire aux performances.
Voir aussi
Tâches
Comment : définir et exécuter des méthodes dynamiques
Concepts
Scénarios d'applications d'émission de réflexion