Compilation et .NET natif.NET Native and Compilation

Les applications Windows 8.1 et les applications de bureau Windows qui ciblent le .NET Framework sont écrites dans un langage de programmation particulier et compilées dans un langage intermédiaire.Windows 8.1 applications and Windows Desktop applications that target the.NET Framework are written in a particular programming language and compiled into intermediate language (IL). Lors de l'exécution, un compilateur juste-à-temps (JIT) est chargé de compiler du langage intermédiaire en code natif pour l'ordinateur local, juste avant qu'une méthode ne soit exécutée pour la première fois.At runtime, a just-in-time (JIT) compiler is responsible for compiling the IL into native code for the local machine just before a method is executed for the first time. À l'inverse, la chaîne d'outils .NET Native convertit le code source en code natif au moment de la compilation.In contrast, the .NET Native tool chain converts source code to native code at compile time. Cette rubrique compare .NET Native avec d'autres technologies de compilation disponibles pour les applications .NET Framework. Elle explique également de façon pratique comment .NET Native génère le code natif qui peut vous aider à comprendre pourquoi les exceptions qui se produisent dans le code compilé avec .NET Native ne se produisent pas dans le code compilé par le compilateur JIT.This topic compares .NET Native with other compilation technologies available for .NET Framework apps, and also provides a practical overview of how .NET Native produces native code that can help you understand why exceptions that occur in code compiled with .NET Native do not occur in JIT-compiled code.

.NET native : Générer des binaires natifs.NET Native: Generating native binaries

Une application qui cible .NET Framework et qui n'est pas compilée à l'aide de la chaîne d'outils .NET Native se compose de votre assembly d'application, qui comprend les éléments suivants :An application that targets the .NET Framework and that is not compiled by using the .NET Native tool chain consists of your application assembly, which includes the following:

  • Des métadonnées qui décrivent l’assembly, ses dépendances, les types qu’il contient et leurs membres.Metadata that describes the assembly, its dependencies, the types it contains, and their members. Les métadonnées sont utilisées pour la réflexion et l'accès à liaison tardive et dans certains cas, par le compilateur et les outils de génération.The metadata is used for reflection and late-bound access, and in some cases by compiler and build tools as well.

  • Du code d'implémentation.Implementation code. Il s’agit des opcodes de langage intermédiaire.This consists of intermediate language (IL) opcodes. Lors de l'exécution, le compilateur juste-à-temps (JIT) le traduit en code natif pour la plateforme cible.At runtime, the just-in-time (JIT) compiler translates it into native code for the target platform.

En plus de votre assembly d'application principal, une application requiert les éléments suivants :In addition to your main application assembly, an app requires that the following be present:

  • Toute bibliothèque de classes supplémentaire ou assembly tiers requis par votre application.Any additional class libraries or third-party assemblies that are required by your app. De même, ces assemblys incluent des métadonnées qui décrivent l'assembly, ses types et leurs membres, ainsi que le langage intermédiaire qui implémente tous les membres de type.These assemblies similarly include metadata that describes the assembly, its types, and their members, as well as the IL that implements all type members.

  • La bibliothèque de classes .NET Framework.The .NET Framework Class Library. Il s’agit d’une collection d’assemblys qui est installée sur le système local avec l’installation de .NET Framework.This is a collection of assemblies that is installed on the local system with the .NET Framework installation. Les assemblys inclus dans la bibliothèque de classes .NET Framework comprennent un ensemble complet de métadonnées et de code d'implémentation.The assemblies included in the .NET Framework Class Library include a complete set of metadata and implementation code.

  • Le common language runtime.The common language runtime. Il s’agit d’une collection de bibliothèques de liens dynamiques qui fournissent des services tels que le chargement des assemblys, la gestion de la mémoire et des garbage collection, la gestion des exceptions, la compilation juste-à-temps, la communication à distance et l’interopérabilité.This is a collection of dynamic link libraries that perform such services as assembly loading, memory management and garbage collection, exception handling, just-in-time compilation, remoting, and interop. Tout comme la bibliothèque de classes, le runtime est installé sur le système local dans le cadre de l'installation .NET Framework.Like the class library, the runtime is installed on the local system as part of the .NET Framework installation.

Notez que l'ensemble du common language runtime, ainsi que les métadonnées et le langage intermédiaire de tous les types contenus dans les assemblys spécifiques à l'application, les assemblys tiers et les assemblys système doivent être présents pour que l'application fonctionne correctement.Note that the entire common language runtime, as well as metadata and IL for all types in application-specific assemblies, third-party assemblies, and system assemblies must be present for the app to execute successfully.

.NET Native et compilation juste-à-temps.NET Native and just-in-time compilation

L'entrée de la chaîne d'outils .NET Native est l'application du Windows Store créée par le compilateur C# ou Visual Basic.The input for the .NET Native tool chain is the Windows store app built by the C# or Visual Basic compiler. En d'autres termes, la chaîne d'outils .NET Native commence l'exécution quand le compilateur de langage a terminé la compilation d'une application du Windows Store.In other words, the .NET Native tool chain begins execution when the language compiler has finished compilation of a Windows Store app.

Conseil

Étant donné que l'entrée de .NET Native correspond au langage intermédiaire et aux métadonnées écrites dans les assemblys managés, vous pouvez toujours effectuer la génération de code personnalisée ou d'autres opérations personnalisées à l'aide d'événements pré-build ou post-build, ou en modifiant le fichier projet MSBuild.Because the input to .NET Native is the IL and metadata written to managed assemblies, you can still perform custom code generation or other custom operations by using pre-build or post-build events or by modifying the MSBuild project file.

Toutefois, les catégories d'outils qui modifient le langage intermédiaire, et empêchent ainsi la chaîne d'outils .NET d'analyser le langage intermédiaire d'une application, ne sont pas prises en charge.However, categories of tools that modify IL and thereby prevent the .NET tool chain from analyzing an app's IL are not supported. Les obfuscateurs sont les outils de ce type les plus connus.Obfuscators are the most notable tools of this type.

Au cours de la conversion d'une application du langage intermédiaire en code natif, la chaîne d'outils .NET Native effectue des opérations telles que les suivantes :In the course of converting an app from IL to native code, the .NET Native tool chain performs operations like the following:

  • Pour certains chemins de code, elle remplace le code qui s’appuie sur la réflexion et les métadonnées par du code natif statique.For certain code paths, it replaces code that relies on reflection and metadata with static native code. Par exemple, si un type valeur ne remplace pas la méthode ValueType.Equals, le test d'égalité par défaut utilise la réflexion pour récupérer les objets FieldInfo qui représentent les champs du type valeur, puis compare les valeurs de champ des deux instances.For example, if a value type does not override the ValueType.Equals method, the default test for equality uses reflection to retrieve FieldInfo objects that represent the value type's fields, then compares the field values of two instances. Lors de la compilation en code natif, la chaîne d'outils .NET Native remplace le code et les métadonnées de réflexion par une comparaison statique des valeurs de champ.When compiling to native code, the .NET Native tool chain replaces the reflection code and metadata with a static comparison of the field values.

  • Quand cela est possible, elle tente d'éliminer toutes les métadonnées.Where possible, it attempts to eliminate all metadata.

  • Elle inclut dans les assemblys de l'application finale uniquement le code d'implémentation qui est réellement appelé par l'application.It includes in the final app assemblies only the implementation code that is actually invoked by the app. Cela affecte particulièrement le code des bibliothèques tierces et de la bibliothèque de classes .NET Framework.This particularly affects code in third-party libraries and in the .NET Framework Class Library. Une application ne dépend donc plus des bibliothèques tierces ni de la bibliothèque de classes .NET Framework complète. Au lieu de cela, le code des bibliothèques tierces et des bibliothèques de classes .NET Framework est désormais local pour l'application.As a result, an application no longer depends on either third-party libraries or the full .NET Framework Class Library; instead, code in third-party and .NET Framework class libraries is now local to the app.

  • Elle remplace le CLR complet par un runtime refactorisé contenant principalement le garbage collector.It replaces the full CLR with a refactored runtime that primarily contains the garbage collector. Le runtime refactorisé se trouve dans une bibliothèque nommée mrt100_app.dll qui est locale pour l'application et dont la taille ne dépasse pas quelques centaines de kilo-octets.The refactored runtime is found in a library named mrt100_app.dll that is local to the app and is only a few hundred kilobytes in size. Ceci est possible parce que la liaison statique rend inutiles la plupart des services fournis par le common language runtime.This is possible because static linking eliminates the need for many of the services performed by the common language runtime.

    Notes

    .NET Native utilise le même garbage collector en tant que common language runtime standard..NET Native uses the same garbage collector as the standard common language runtime. Dans le garbage collector .NET Native, le garbage collection d'arrière-plan est activé par défaut.In the .NET Native garbage collector, background garbage collection is enabled by default. Pour plus d’informations sur le garbage collection, consultez Notions de base du garbage collection.For more information about garbage collection, see Fundamentals of Garbage Collection.

Important

.NET Native compile une application entière en une application native..NET Native compiles an entire application to a native application. Il ne vous permet pas de compiler en code natif un assembly unique contenant une bibliothèque de classes pour que celui-ci puisse être appelé de manière autonome depuis le code managé.It does not allow you to compile a single assembly that contains a class library to native code so that it can be called independently from managed code.

L’application résultante produite par la chaîne d’outils .NET Native est écrite dans un répertoire nommé ilc.out, lui-même situé dans le répertoire Debug ou Release de votre répertoire de projet.The resulting app that is produced by the .NET Native tool chain is written to a directory named ilc.out in the Debug or Release directory of your project directory. Elle se compose des fichiers suivants :It consists of the following files:

  • <nom_application>.exe, un exécutable stub qui cède le contrôle à une exportation Main spéciale dans <nom_application>.dll.<appName>.exe, a stub executable that simply transfers control to a special Main export in <appName>.dll.

  • <nom_application>.dll, une bibliothèque de liens dynamiques Windows qui contient le code de votre application, ainsi que du code provenant de la bibliothèque de classes .NET Framework et de toute bibliothèque tierce avec laquelle il existe une dépendance.<appName>.dll, a Windows dynamic link library that contains all your application code, as well as code from the .NET Framework Class Library and any third-party libraries that you have a dependency on. Elle contient également le code de prise en charge, tel que le code nécessaire pour interagir avec Windows et sérialiser les objets de votre application.It also contains support code, such as the code necessary to interoperate with Windows and to serialize objects in your app.

  • mrt100_app.dll, un runtime refactorisé qui fournit des services d’exécution tels que le garbage collection.mrt100_app.dll, a refactored runtime that provides runtime services such as garbage collection.

Toutes les dépendances sont capturées par le manifeste APPX de l'application.All dependencies are captured by the app's APPX manifest. En plus des fichiers .exe, .dll et mrt100_app.dll de l'application, qui sont fournis directement avec le package appx, deux autres fichiers sont inclus :In addition to the application exe, dll, and mrt100_app.dll, which are bundled directly in the appx package, this includes two more files:

  • msvcr140_app.dll, la bibliothèque Runtime C (CRT) utilisée par mrt100_app.dll.msvcr140_app.dll, the C run-time (CRT) library used by mrt100_app.dll. Il est fourni par une référence de framework du package.It is included by a framework reference in the package.

  • mrt100.dll.mrt100.dll. Cette bibliothèque inclut des fonctions qui peuvent améliorer les performances de mrt100_app.dll, bien que son absence n'empêche pas mrt100_app.dll de fonctionner.This library includes functions that can improve the performance of mrt100_app.dll, although its absence does not prevent mrt100_app.dll from functioning. Elle est chargée à partir du répertoire system32 sur l'ordinateur local, s'il s'y trouve.It is loaded from the system32 directory on the local machine, if it is present.

Étant donné que la chaîne d'outils .NET Native ne lie le code d'implémentation à votre application que s'il sait que votre application appelle ce code, les métadonnées ou le code d'implémentation requis dans les scénarios suivants peuvent ne pas être inclus dans votre application :Because the .NET Native tool chain links implementation code into your app only if it knows that your app actually invokes that code, either the metadata or the implementation code required in the following scenarios may not be included with your app:

  • Réflexion.Reflection.

  • Appel dynamique ou à liaison tardiveDynamic or late-bound invocation.

  • Sérialisation et désérialisationSerialization and deserialization.

  • COM InteropCOM interop.

Si le code d'implémentation ou les métadonnées nécessaires sont absents au moment de l'exécution, le runtime .NET Native lève une exception.If the necessary metadata or implementation code is absent at runtime, the .NET Native runtime throws an exception. Vous pouvez éviter ces exceptions et vérifier que la chaîne d’outils .NET Native inclut le code d’implémentation et les métadonnées nécessaires en utilisant un fichier de directives runtime. Il s’agit d’un fichier XML qui désigne les éléments de programme dont le code d’implémentation ou les métadonnées doivent être disponibles lors de l’exécution, et qui leur attribue une stratégie runtime.You can prevent these exceptions, and ensure that the .NET Native tool chain includes the required metadata and implementation code, by using a runtime directives file, an XML file that designates the program elements whose metadata or implementation code must be available at runtime and assigns a runtime policy to them. Voici le fichier de directives runtime par défaut qui est ajouté à un projet Windows Store compilé par la chaîne d'outils .NET Native :The following is the default runtime directives file that is added to a Windows Store project that is compiled by the .NET Native tool chain:

<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">  
  <Application>  
    <Assembly Name="*Application*" Dynamic="Required All" />  
  </Application>  
</Directives>  

Il permet à tous les types, ainsi qu'à tous leurs membres, dans tous les assemblys de votre package d'application, de faire l'objet d'une réflexion et d'un appel dynamique.This enables all the types, as well as all their members, in all the assemblies in your app package for reflection and dynamic invocation. Toutefois, il ne le permet pas aux types des assemblys de la bibliothèque de classes .NET Framework.However, it does not enable reflection or dynamic activation of types in .NET Framework Class Library assemblies. Dans de nombreux cas, cela suffit.In many cases, this is adequate.

.NET Native et NGEN.NET Native and NGEN

Le générateur d’images natives (NGEN) compile des assemblys en code natif et les installe dans le cache d’images natives sur l’ordinateur local.The (Native Image Generator (NGEN) compiles assemblies to native code and installs them in the native image cache on the local computer. Toutefois, même si NGEN génère du code natif comme .NET Native, il comporte des différences importantes :However, although NGEN, like .NET Native, produces native code, it differs from .NET Native in some significant ways:

  • Si aucune image native n'est disponible pour une méthode particulière, NGEN revient au code juste-à-temps.If no native image is available for a particular method, NGEN falls back to JITing code. Cela signifie que les images natives doivent continuer d'inclure les métadonnées et le langage intermédiaire dans le cas où NGEN doive revenir à la compilation juste-à-temps.This means that native images must continue to include metadata and IL in the event that NGEN needs to fall back to JIT compilation. À l'inverse, .NET Native génère uniquement des images natives et ne revient pas à la compilation juste-à-temps.In contrast, .NET Native produces only native images and does not fall back to JIT compilation. Seules les métadonnées requises pour certains scénarios d'interopérabilité, de sérialisation et de réflexion doivent donc être conservées.As a result, only metadata required for some reflection, serialization, and interop scenarios must be preserved.

  • NGEN continue à s’appuyer sur le common language runtime complet pour des services tels que le chargement d’assemblys, la communication à distance, l’interopérabilité, la gestion de la mémoire, le garbage collection et, si nécessaire, la compilation JIT.NGEN continues to rely on the full common language runtime for services such as assembly loading, remoting, interop, memory management, garbage collection, and, if necessary, JIT compilation. Dans .NET Native, plusieurs de ces services sont soit inutiles (la compilation JIT), soit résolus au moment de la génération, puis incorporés dans l'assembly de l'application.In .NET Native, many of these services are either unnecessary (JIT compilation) or are resolved at build-time and incorporated in the app assembly. Les services restants, le plus important étant le garbage collection, sont inclus dans un runtime refactorisé beaucoup plus petit nommé mrt100_app.dll.The remaining services, the most important of which is garbage collection, are included in a much smaller, refactored runtime named mrt100_app.dll.

  • Les images NGEN ont tendance à être fragiles.NGEN images tend to be fragile. Par exemple, un correctif ou une modification apportée à une dépendance requièrent généralement que les assemblys qui l'utilisent soient également régénérés par NGEN.For example, a patch or change to a dependency typically requires that the assemblies that use it also be re-NGENed. Ceci est particulièrement vrai pour les assemblys système de la bibliothèque de classes .NET Framework.This is particularly true of system assemblies in the .NET Framework Class Library. À l'inverse, .NET Native permet aux applications d'être fournies indépendamment les unes des autres.In contrast, .NET Native allows applications to be served independently of one another.

Voir aussiSee also