processus d'exécution managéeManaged Execution Process

Le processus d'exécution managé inclut les étapes suivantes,qui sont décrites en détail plus loin dans cette rubrique :The managed execution process includes the following steps, which are discussed in detail later in this topic:

  1. Choix d'un compilateurChoosing a compiler.

    Pour bénéficier des avantages qu'apporte le Common Language Runtime, vous devez utiliser un ou plusieurs compilateurs de langage ciblant le runtime.To obtain the benefits provided by the common language runtime, you must use one or more language compilers that target the runtime.

  2. Compilation de votre code en MSILCompiling your code to MSIL.

    La compilation traduit votre code source en langage MSIL (Microsoft Intermediate Language) et génère les métadonnées requises.Compiling translates your source code into Microsoft intermediate language (MSIL) and generates the required metadata.

  3. Compilation du MSIL en code natifCompiling MSIL to native code.

    Au moment de l'exécution, un compilateur juste-à-temps (JIT) transforme le MSIL en code natif.At execution time, a just-in-time (JIT) compiler translates the MSIL into native code. Au moment de la compilation, le code est soumis à un processus de vérification qui examine le MSIL et les métadonnées afin de déterminer si le code peut être considéré comme étant de type sécurisé.During this compilation, code must pass a verification process that examines the MSIL and metadata to find out whether the code can be determined to be type safe.

  4. Exécution de codeRunning code.

    Le Common Language Runtime fournit l'infrastructure qui permet à l'exécution d'avoir lieu et les services pouvant être utilisés pendant l'exécution.The common language runtime provides the infrastructure that enables execution to take place and services that can be used during execution.

Choix d'un compilateurChoosing a Compiler

Pour bénéficier des avantages qu'offre le Common Language Runtime (CLR), vous devez utiliser un ou plusieurs compilateurs de langage ciblant le runtime, tels que les compilateurs Visual Basic, C#, Visual C++, F# ou l'un des nombreux compilateurs tiers tels que les compilateurs Eiffel, Perl ou COBOL.To obtain the benefits provided by the common language runtime (CLR), you must use one or more language compilers that target the runtime, such as Visual Basic, C#, Visual C++, F#, or one of many third-party compilers such as an Eiffel, Perl, or COBOL compiler.

Dans la mesure où il représente un environnement d'exécution multilangage, le runtime prend en charge une grande variété de types de données et de fonctionnalités de langage.Because it is a multilanguage execution environment, the runtime supports a wide variety of data types and language features. Le compilateur de langage que vous utilisez détermine les fonctionnalités du runtime qui sont disponibles et que vous utilisez pour concevoir votre code.The language compiler you use determines which runtime features are available, and you design your code using those features. C'est votre compilateur et non le runtime qui établit la syntaxe à laquelle votre code doit se conformer.Your compiler, not the runtime, establishes the syntax your code must use. Si votre composant doit être entièrement utilisable par des composants écrits dans d’autres langages, les types exportés de votre composant doivent exposer uniquement les fonctionnalités de langage qui font partie de la spécification Language Independence and Language-Independent Components .If your component must be completely usable by components written in other languages, your component's exported types must expose only language features that are included in the Language Independence and Language-Independent Components (CLS). Vous pouvez utiliser l'attribut CLSCompliantAttribute pour vous assurer que votre code est conforme CLS.You can use the CLSCompliantAttribute attribute to ensure that your code is CLS-compliant. Pour plus d'informations, consultez Language Independence and Language-Independent Components.For more information, see Language Independence and Language-Independent Components.

Retour au débutBack to top

Compilation en MSILCompiling to MSIL

Lors d'une compilation destinée à produire du code managé, le compilateur convertit le code source en langage MSIL (Microsoft Intermediate Language), un jeu d'instructions indépendant du processeur qui peut être converti efficacement en code natif.When compiling to managed code, the compiler translates your source code into Microsoft intermediate language (MSIL), which is a CPU-independent set of instructions that can be efficiently converted to native code. MSIL inclut des instructions pour le chargement, le stockage, l'initialisation et l'appel de méthodes sur des objets, ainsi que des instructions pour la réalisation d'opérations arithmétiques et logiques, le flux de contrôle, l'accès direct à la mémoire, la gestion des exceptions et d'autres opérations.MSIL includes instructions for loading, storing, initializing, and calling methods on objects, as well as instructions for arithmetic and logical operations, control flow, direct memory access, exception handling, and other operations. Avant d'exécuter du code, vous devez d'abord convertir le MSIL en code spécifique au processeur, généralement à l'aide d'un compilateur juste-à-temps (JIT).Before code can be run, MSIL must be converted to CPU-specific code, usually by a just-in-time (JIT) compiler. Dans la mesure où le Common Language Runtime fournit un ou plusieurs compilateurs JIT pour chaque architecture d'ordinateur qu'il prend en charge, le même jeu d'instructions MSIL peut être traité par un compilateur JIT et exécuté sur toute architecture prise en charge.Because the common language runtime supplies one or more JIT compilers for each computer architecture it supports, the same set of MSIL can be JIT-compiled and run on any supported architecture.

Quand un compilateur produit du code MSIL, il génère aussi des métadonnées.When a compiler produces MSIL, it also produces metadata. Les métadonnées décrivent les types contenus dans votre code, y compris la définition de chaque type, les signatures des membres de chaque type, les membres référencés par votre code, et d'autres données que le runtime utilise au moment de l'exécution.Metadata describes the types in your code, including the definition of each type, the signatures of each type's members, the members that your code references, and other data that the runtime uses at execution time. Le MSIL et les métadonnées sont stockés dans un fichier exécutable portable (PE) qui est basé sur le fichier Microsoft PE publié qu'il prolonge et sur le format COFF (Common Object File Format) utilisé traditionnellement pour le contenu exécutable.The MSIL and metadata are contained in a portable executable (PE) file that is based on and that extends the published Microsoft PE and common object file format (COFF) used historically for executable content. Ce format de fichier, qui accepte le code MSIL ou le code natif ainsi que les métadonnées, permet au système d'exploitation de reconnaître les images du Common Language Runtime.This file format, which accommodates MSIL or native code as well as metadata, enables the operating system to recognize common language runtime images. La présence de métadonnées dans le fichier en même temps que le jeu d'instructions MSIL permet à votre code de se décrire lui-même, ce qui signifie que les bibliothèques de types et IDL (Interface Definition Language) ne sont pas nécessaires.The presence of metadata in the file together with MSIL enables your code to describe itself, which means that there is no need for type libraries or Interface Definition Language (IDL). Le runtime recherche les métadonnées dans le fichier et les extrait selon les besoins, au moment de l'exécution.The runtime locates and extracts the metadata from the file as needed during execution.

Retour au débutBack to top

Compilation du MSIL en code natifCompiling MSIL to Native Code

Avant de pouvoir exécuter le langage MSIL (MicroSoft Intermediate Language), vous devez le compiler en code natif avec le Common Language Runtime pour l'architecture de l'ordinateur cible.Before you can run Microsoft intermediate language (MSIL), it must be compiled against the common language runtime to native code for the target machine architecture. Le .NET Framework propose deux méthodes pour effectuer cette conversion :The .NET Framework provides two ways to perform this conversion:

Compilation par le compilateur JITCompilation by the JIT Compiler

La compilation JIT convertit à la demande le langage MSIL en code natif au moment de l'exécution de l'application, quand le contenu d'un assembly est chargé et exécuté.JIT compilation converts MSIL to native code on demand at application run time, when the contents of an assembly are loaded and executed. Dans la mesure où le Common Language Runtime fournit un compilateur JIT pour chaque architecture de processeur qu'il prend en charge, les développeurs peuvent générer un jeu d'assemblys MSIL pouvant être traité par un compilateur JIT et exécuté sur différents ordinateurs ayant des architectures d'ordinateur différentes.Because the common language runtime supplies a JIT compiler for each supported CPU architecture, developers can build a set of MSIL assemblies that can be JIT-compiled and run on different computers with different machine architectures. Cependant, si votre code managé appelle des API natives spécifiques à une plateforme ou une bibliothèque de classes spécifique à une plateforme, il s'exécutera sur un système d'exploitation spécifique uniquement.However, if your managed code calls platform-specific native APIs or a platform-specific class library, it will run only on that operating system.

La compilation JIT tient compte de la possibilité qu'une partie du code ne soit peut-être jamais appelée au moment de l'exécution.JIT compilation takes into account the possibility that some code might never be called during execution. Au lieu de consacrer du temps et des ressources mémoire à la conversion de toutes les instructions MSIL d'un fichier PE en code natif, elle les convertit au fur et à mesure des besoins au moment de l'exécution et stocke le code natif obtenu en mémoire afin qu'il soit accessible pour les appels ultérieurs dans le contexte de ce processus.Instead of using time and memory to convert all the MSIL in a PE file to native code, it converts the MSIL as needed during execution and stores the resulting native code in memory so that it is accessible for subsequent calls in the context of that process. Le chargeur crée et attache un stub à chaque méthode dans un type quand le type est chargé et initialisé.The loader creates and attaches a stub to each method in a type when the type is loaded and initialized. Quand une méthode est appelée pour la première fois, le stub passe le contrôle au compilateur JIT, qui convertit le MSIL de cette méthode en code natif et modifie le stub afin de pointer directement vers le code natif généré.When a method is called for the first time, the stub passes control to the JIT compiler, which converts the MSIL for that method into native code and modifies the stub to point directly to the generated native code. Par conséquent, les appels suivants à la méthode traitée par le compilateur JIT passent directement au code natif.Therefore, subsequent calls to the JIT-compiled method go directly to the native code.

Génération du code d'installation à l'aide de NGen.exeInstall-Time Code Generation Using NGen.exe

Comme le compilateur JIT convertit le MSIL d'un assembly en code natif quand les méthodes individuelles définies dans cet assembly sont appelées, les performances sont nécessairement altérées au moment de l'exécution.Because the JIT compiler converts an assembly's MSIL to native code when individual methods defined in that assembly are called, it affects performance adversely at run time. Dans la plupart des cas, cette baisse de performances est acceptable.In most cases, that diminished performance is acceptable. Et surtout, le code généré par le compilateur JIT est lié au processus qui a déclenché la compilation.More importantly, the code generated by the JIT compiler is bound to the process that triggered the compilation. Il ne peut pas être partagé entre plusieurs processus.It cannot be shared across multiple processes. Pour que le code généré puisse être partagé entre plusieurs appels d'une application ou entre plusieurs processus partageant un jeu d'assemblys, le Common Language Runtime prend en charge un mode de compilation à l'avance.To allow the generated code to be shared across multiple invocations of an application or across multiple processes that share a set of assemblies, the common language runtime supports an ahead-of-time compilation mode. Ce mode de compilation à l’avance utilise Ngen.exe (générateur d’images natives) pour convertir les assemblys MSIL en code natif de façon similaire au compilateur JIT.This ahead-of-time compilation mode uses the Ngen.exe (Native Image Generator) to convert MSIL assemblies to native code much like the JIT compiler does. Toutefois, le fonctionnement de Ngen.exe diffère de celui du compilateur JIT sur trois points :However, the operation of Ngen.exe differs from that of the JIT compiler in three ways:

  • Il exécute la conversion de MSIL en code natif avant d'exécuter l'application et non pendant l'exécution de celle-ci.It performs the conversion from MSIL to native code before running the application instead of while the application is running.

  • Il compile un assembly entier à la fois, au lieu d'une méthode à la fois.It compiles an entire assembly at a time, instead of one method at a time.

  • Il conserve le code généré dans le cache des images natives comme un fichier sur le disque.It persists the generated code in the Native Image Cache as a file on disk.

Vérification du codeCode Verification

Dans le cadre de sa compilation en code natif, le code MSIL est soumis à un processus de vérification, sauf si un administrateur a établi une stratégie de sécurité qui autorise le code à ignorer ce processus.As part of its compilation to native code, the MSIL code must pass a verification process unless an administrator has established a security policy that allows the code to bypass verification. La vérification examine le MSIL et les métadonnées afin de déterminer si le code est de type sécurisé, ce qui signifie qu'il ne doit accéder qu'aux emplacements de mémoire autorisés.Verification examines MSIL and metadata to find out whether the code is type safe, which means that it accesses only the memory locations it is authorized to access. La sécurité de type permet d'isoler les objets les uns des autres et de les protéger de toute altération accidentelle ou malveillante.Type safety helps isolate objects from each other and helps protect them from inadvertent or malicious corruption. Elle garantit également que les restrictions liées à la sécurité peuvent être appliquées au code de manière fiable.It also provides assurance that security restrictions on code can be reliably enforced.

Le runtime s'appuie sur le fait que les instructions suivantes sont vraies pour le code de type sécurisé vérifié :The runtime relies on the fact that the following statements are true for code that is verifiably type safe:

  • une référence à un type qui est strictement compatible avec le type référencé ;A reference to a type is strictly compatible with the type being referenced.

  • seules les opérations définies de façon appropriée sont appelées pour un objet ;Only appropriately defined operations are invoked on an object.

  • les identités sont conformes à ce qu'elles prétendent être.Identities are what they claim to be.

Pendant le processus de vérification, le code MSIL est examiné en vue d'essayer de confirmer qu'il peut accéder aux emplacements de mémoire et appeler des méthodes uniquement par le biais de types correctement définis.During the verification process, MSIL code is examined in an attempt to confirm that the code can access memory locations and call methods only through properly defined types. Par exemple, le code n'autorise pas l'accès aux champs d'un objet d'une manière qui accepte le débordement de capacité des emplacements de mémoire.For example, code cannot allow an object's fields to be accessed in a manner that allows memory locations to be overrun. Par ailleurs, le processus de vérification inspecte le code MSIL afin de déterminer s'il a été généré correctement, car un code MSIL incorrect peut donner lieu à une violation des règles de sécurité des types.Additionally, verification inspects code to determine whether the MSIL has been correctly generated, because incorrect MSIL can lead to a violation of the type safety rules. Le processus de vérification passe un jeu de code de type sécurisé et correctement défini, et ne passe que du code de ce type.The verification process passes a well-defined set of type-safe code, and it passes only code that is type safe. Cependant, une partie du code de type sécurisé peut ne pas passer le test de vérification avec succès en raison de certaines limitations du processus de vérification, et certains langages, de par leur design, ne produisent pas un code de type sécurisé vérifié.However, some type-safe code might not pass verification because of some limitations of the verification process, and some languages, by design, do not produce verifiably type-safe code. Si le code de type sécurisé est requis par la stratégie de sécurité, mais qu'il ne passe pas le test de vérification avec succès, une exception est levée quand le code est exécuté.If type-safe code is required by the security policy but the code does not pass verification, an exception is thrown when the code is run.

Retour au débutBack to top

Exécution de codeRunning Code

Le Common Language Runtime fournit l'infrastructure qui permet à l'exécution managée d'avoir lieu et les services pouvant être utilisés pendant l'exécution.The common language runtime provides the infrastructure that enables managed execution to take place and services that can be used during execution. Pour qu'une méthode puisse être exécutée, elle doit d'abord être compilée en un code spécifique au processeur.Before a method can be run, it must be compiled to processor-specific code. Chaque méthode pour laquelle le MSIL a été généré est compilée juste-à-temps quand elle est appelée pour la première fois, puis s'exécute.Each method for which MSIL has been generated is JIT-compiled when it is called for the first time, and then run. Quand la méthode est exécutée la fois suivante, le code natif existant traité par le compilateur JIT est exécuté.The next time the method is run, the existing JIT-compiled native code is run. Le processus de compilation JIT puis d'exécution du code est répété jusqu'à ce que l'exécution soit complètement terminée.The process of JIT-compiling and then running the code is repeated until execution is complete.

Pendant l'exécution, le code managé bénéficie de services tels que le garbage collection, la sécurité, l'interopérabilité avec le code non managé, la prise en charge du débogage interlangage ainsi que la prise en charge améliorée du déploiement et du versioning.During execution, managed code receives services such as garbage collection, security, interoperability with unmanaged code, cross-language debugging support, and enhanced deployment and versioning support.

Dans Microsoft Windows Vista, le chargeur de système d’exploitation vérifie les modules gérés en examinant un peu l’en-tête COFF.In Microsoft Windows Vista, the operating system loader checks for managed modules by examining a bit in the COFF header. Le bit défini indique un module managé.The bit being set denotes a managed module. Si le chargeur détecte des modules managés, il charge mscoree.dll. _CorValidateImage et _CorImageUnloading informent le chargeur quand les images de modules managés sont chargées et déchargées.If the loader detects managed modules, it loads mscoree.dll, and _CorValidateImage and _CorImageUnloading notify the loader when the managed module images are loaded and unloaded. _CorValidateImage effectue les actions suivantes :_CorValidateImage performs the following actions:

  1. garantit que le code est du code managé valide ;Ensures that the code is valid managed code.

  2. change le point d'entrée dans l'image en point d'entrée dans le runtime.Changes the entry point in the image to an entry point in the runtime.

Sous Windows 64 bits, _CorValidateImage modifie l'image en mémoire en la transformant du format PE32 au format PE32+.On 64-bit Windows, _CorValidateImage modifies the image that is in memory by transforming it from PE32 to PE32+ format.

Retour au débutBack to top

Voir aussiSee also