Scénarios d'applications de Reflection Emit

Cette section décrit quelques scénarios dans lesquels des applications utilisent Reflection Emit.

Exécution d'un script dans un navigateur Web

Dans ce scénario, un navigateur Web charge une page HTML contenant un programme de script et exécute ce dernier. Les étapes sont les suivantes :

1. Le navigateur Web lance le moteur de script dans le domaine d'application du navigateur Web.
2. Le navigateur Web extrait le script de la page HTML et le passe au moteur de script.
3. Le moteur de script créé un assembly dynamique transitoire.
4. Le moteur de script utilise les interfaces API Reflection Emit pour émettre le code dans l'assembly dynamique.

Exécution d'un script dans une page ASP.NET

Dans ce scénario, un navigateur ouvre une page ASP.NET contenant un programme de script. Le programme est compilé sur le serveur et exécuté. Les étapes sont les suivantes :

1. ASP.NET démarre son domaine d'application et lance le moteur de script pour compiler et exécuter le programme.
2. Le moteur de script crée un assembly dynamique persistable et un module dynamique persistable dans l'assembly dynamique.
3. Le moteur de script compile le programme en utilisant les interfaces API Reflection Emit et émet le code dans le module dynamique persistable.
4. Le code compilé est exécuté et une expression eval est rencontrée.
5. Le moteur de script crée un module dynamique transitoire dans l'assembly dynamique pour contenir le code pour l'expression eval.
6. Le moteur de script évalue l'expression eval en exécutant le module dynamique transitoire.
7. ASP.NET demande au moteur de script d'enregistrer l'assembly dynamique et le module dynamique persistable dans le cache pour ne pas avoir à recompiler le script lorsque la page est revisitée.

Compilation d'une expression régulière en utilisant Reflection Emit

Dans ce scénario, un compilateur utilise Reflection Emit pour compiler des expressions régulières dans le code source. Un utilisateur peut déclarer les expressions régulières à compiler. Les étapes sont les suivantes :

1. Le compilateur traite la première utilisation d'une expression régulière dans le code source d'un utilisateur.
2. Le compilateur compile l'expression régulière dans une classe scanner personnalisée en utilisant Reflection Emit car l'utilisateur a demandé que l'expression soit compilée. L'expression régulière est tout d'abord traduite en codes d'opération de l'expression régulière du compilateur. Par exemple, une instruction peut spécifier : « Essayer de faire correspondre zéro lettres "a" ou plus ». Les codes d'opération de l'expression régulière sont ensuite traduits en langage MSIL (Microsoft Intermediate Language). Par exemple, le compilateur peut générer une boucle qui itère toutes les occurrences de la lettre « a » trouvée.
3. Le compilateur enregistre la classe scanner compilée pour une utilisation ultérieure.
4. Le compilateur instancie la classe scanner compilée et exécute le code dans le domaine d'application en cours.
5. Le compilateur traite la prochaine utilisation de la même expression régulière dans le code source de l'utilisateur.
6. Le compilateur extrait la classe scanner compilée pour l'expression régulière, l'instancie et exécute le code dans le domaine d'application en cours.

L'utilisateur est pénalisé en matière de performance lorsque la première instance d'une expression régulière est utilisée car le compilateur doit compiler l'expression en une classe scanner. Cependant, les utilisations suivantes de la même expression régulière sont exécutées efficacement. Pour les expressions régulières qui ne sont pas fréquemment utilisées, la pénalité de compilation de départ est insignifiante car le temps d'exécution peut être considérablement amélioré.

Voir aussi

Scénarios Reflection Emit | Expressions régulières du .NET Framework