Ngen.exe (Native Image Generator)Ngen.exe (Native Image Generator)

L'outil Native Image Generator Tool (Ngen.exe) est un outil qui améliore les performances des applications managées.The Native Image Generator (Ngen.exe) is a tool that improves the performance of managed applications. Ngen.exe crée des images natives, qui sont des fichiers contenant le code machine compilé spécifique au processeur, et les installe dans le cache des images natives sur l'ordinateur local.Ngen.exe creates native images, which are files containing compiled processor-specific machine code, and installs them into the native image cache on the local computer. Le runtime peut utiliser des images natives du cache plutôt que le compilateur juste-à-temps (JIT) pour compiler l'assembly d'origine.The runtime can use native images from the cache instead of using the just-in-time (JIT) compiler to compile the original assembly.

Notes

Ngen.exe compile les images natives pour les assemblys qui ciblent le .NET Framework uniquement.Ngen.exe compiles native images for assemblies that target the .NET Framework only. Le générateur d’images natives équivalent pour .NET Core est CrossGen.The equivalent native image generator for .NET Core is CrossGen.

Modifications apportées à Ngen.exe dans .NET Framework 4 :Changes to Ngen.exe in the .NET Framework 4:

  • Ngen.exe compile maintenant des assemblys avec une confiance totale et la stratégie de sécurité d'accès du code (CAS) n'est plus évaluée.Ngen.exe now compiles assemblies with full trust, and code access security (CAS) policy is no longer evaluated.

  • Les images natives générées avec Ngen.exe ne peuvent plus être chargées dans les applications qui s'exécutent avec une confiance partielle.Native images that are generated with Ngen.exe can no longer be loaded into applications that are running in partial trust.

Modifications apportées à Ngen.exe dans le .NET Framework version 2.0 :Changes to Ngen.exe in the .NET Framework version 2.0:

  • L'installation d'un assembly installe également ses dépendances, en simplifiant la syntaxe de Ngen.exe.Installing an assembly also installs its dependencies, simplifying the syntax of Ngen.exe.

  • Les images natives peuvent maintenant être partagées entre les domaines d'application.Native images can now be shared across application domains.

  • Une nouvelle action, update, recrée des images qui ont été invalidées.A new action, update, re-creates images that have been invalidated.

  • L'exécution des actions peuvent être différées par un service qui utilise la durée d'inactivité de l'ordinateur pour générer et installer des images.Actions can be deferred for execution by a service that uses idle time on the computer to generate and install images.

  • Certaines causes d'invalidation d'images ont été éliminées.Some causes of image invalidation have been eliminated.

Sur Windows 8, consultez Tâche d’image native.On Windows 8, see Native Image Task.

Pour plus d'informations sur l'utilisation de Ngen.exe et du service d'images natives, consultez Service d'images natives.For additional information on using Ngen.exe and the native image service, see Native Image Service.

Notes

Vous trouverez la syntaxe de Ngen.exe pour les versions 1.0 et 1.1 du .NET Framework dans Syntaxe héritée du générateur d’images natives (Ngen.exe).Ngen.exe syntax for versions 1.0 and 1.1 of the .NET Framework can be found in Native Image Generator (Ngen.exe) Legacy Syntax.

Cet outil est installé automatiquement avec Visual Studio.This tool is automatically installed with Visual Studio. Pour exécuter l’outil, utilisez l’invite de commandes développeur pour Visual Studio (ou l’invite de commandes Visual Studio dans Windows 7).To run the tool, use the Developer Command Prompt for Visual Studio (or the Visual Studio Command Prompt in Windows 7). Pour plus d'informations, consultez Invites de commandes.For more information, see Command Prompts.

À l'invite de commandes, tapez le texte suivant :At the command prompt, type the following:

SyntaxeSyntax

ngen action [options]
ngen /? | /help

ActionsActions

Le tableau ci-après décrit la syntaxe de chaque action.The following table shows the syntax of each action. Pour obtenir une description de chaque partie d’une action, consultez les tableaux Arguments, Niveaux de priorité, Scénarios et Config.For descriptions of the individual parts of an action, see the Arguments, Priority Levels, Scenarios, and Config tables. Le tableau Options décrit les options et les commutateurs d'aide.The Options table describes the options and the help switches.

ActionAction DescriptionDescription
install [assemblyName | assemblyPath] [scenarios] [config] [/queue[:{1|2|3}]]install [assemblyName | assemblyPath] [scenarios] [config] [/queue[:{1|2|3}]] Générer des images natives pour un assembly et ses dépendances et installer les images dans le cache des images natives.Generate native images for an assembly and its dependencies and install the images in the native image cache.

Si /queue est spécifié, l'action est mise en file d'attente pour le service d'images natives.If /queue is specified, the action is queued for the native image service. La priorité par défaut est 3.The default priority is 3. Consultez le tableau Niveaux de priorité.See the Priority Levels table.
uninstall [assemblyName | assemblyPath] [scenarios] [config]uninstall [assemblyName | assemblyPath] [scenarios] [config] Supprimer les images natives d'un assembly et ses dépendances du cache des images natives.Delete the native images of an assembly and its dependencies from the native image cache.

Pour désinstaller une seule image et ses dépendances, utilisez les mêmes arguments de ligne de commande que ceux utilisés pour installer l’image.To uninstall a single image and its dependencies, use the same command-line arguments that were used to install the image. Remarque : À compter de .NET Framework 4, l’action uninstall * n’est plus prise en charge.Note: Starting with the .NET Framework 4, the action uninstall * is no longer supported.
update [/queue]update [/queue] Mettre à jour des images natives qui sont devenues non valides.Update native images that have become invalid.

Si /queue est spécifié, les mises à jour sont mises en file d'attente pour le service d'images natives.If /queue is specified, the updates are queued for the native image service. Les mises à jour sont toujours planifiées à la priorité 3, de sorte qu'elles s'exécutent lorsque l'ordinateur est inactif.Updates are always scheduled at priority 3, so they run when the computer is idle.
display [assemblyName | assemblyPath]display [assemblyName | assemblyPath] Afficher l'état des images natives pour un assembly et ses dépendances.Display the state of the native images for an assembly and its dependencies.

Si aucun argument n’est fourni, tout dans le cache des images natives est affiché.If no argument is supplied, everything in the native image cache is displayed.
executeQueuedItems [1|2|3]executeQueuedItems [1|2|3]

-ou--or-

eqi [1|2|3]eqi [1|2|3]
Exécuter les travaux de compilation en attente.Execute queued compilation jobs.

Si une priorité est spécifiée, les travaux de compilation présentant une priorité supérieure ou égale sont exécutés.If a priority is specified, compilation jobs with greater or equal priority are executed. Si aucune priorité n'est spécifiée, tous les travaux de compilation en attente sont exécutés.If no priority is specified, all queued compilation jobs are executed.
queue {pause | continue | status}queue {pause | continue | status} Suspendre le service d'images natives, reprendre le service suspendu ou interroger l'état du service.Pause the native image service, allow the paused service to continue, or query the status of the service.

ArgumentsArguments

ArgumentArgument DescriptionDescription
assemblyName Nom complet de l'assembly.The full display name of the assembly. Par exemple, "myAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0038abc9deabfle5".For example, "myAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0038abc9deabfle5". Remarque : Vous pouvez fournir un nom d'assembly partiel, tel que myAssembly, pour les actions display et uninstall.Note: You can supply a partial assembly name, such as myAssembly, for the display and uninstall actions.

Un seul assembly peut être spécifié par la ligne de commande Ngen.exe.Only one assembly can be specified per Ngen.exe command line.
assemblyPath Chemin d’accès explicite de l’assembly.The explicit path of the assembly. Vous pouvez spécifier un chemin d'accès complet ou relatif.You can specify a full or relative path.

Si vous spécifiez un nom de fichier sans chemin d'accès, l'assembly doit se trouver dans le répertoire actif.If you specify a file name without a path, the assembly must be located in the current directory.

Un seul assembly peut être spécifié par la ligne de commande Ngen.exe.Only one assembly can be specified per Ngen.exe command line.

Niveaux de prioritéPriority Levels

PrioritéPriority DescriptionDescription
1 Les images natives sont générées et installées immédiatement, sans attendre la durée d'inactivité.Native images are generated and installed immediately, without waiting for idle time.
2 Les images natives sont générées et installées sans attendre la durée d'inactivité, mais après la fin de toutes les actions de priorité 1 (et de leurs dépendances).Native images are generated and installed without waiting for idle time, but after all priority 1 actions (and their dependencies) have completed.
3 Les images natives sont installées lorsque le service d'images natives détecte que l'ordinateur est inactif.Native images are installed when the native image service detects that the computer is idle. Consultez Service d'images natives.See Native Image Service.

ScénariosScenarios

ScénarioScenario DescriptionDescription
/Debug Générer des images natives qui peuvent être utilisées sous un débogueur.Generate native images that can be used under a debugger.
/Profile Générer des images natives qui peuvent être utilisées sous un profileur.Generate native images that can be used under a profiler.
/NoDependencies Générer le nombre minimal d'images natives requis par les options de scénario spécifiées.Generate the minimum number of native images required by the specified scenario options.

ConfigConfig

ConfigurationConfiguration DescriptionDescription
/ExeConfig: exePath/ExeConfig: exePath Utiliser la configuration de l'assembly exécutable spécifiée.Use the configuration of the specified executable assembly.

Ngen.exe doit prendre les mêmes décisions que le chargeur lors de la liaison avec les dépendances.Ngen.exe needs to make the same decisions as the loader when binding to dependencies. Lorsqu'un composant partagé est chargé au moment de l'exécution, à l'aide de la méthode Load, le fichier de configuration de l'application détermine les dépendances qui sont chargées pour le composant partagé, par exemple, la version d'une dépendance qui est chargée.When a shared component is loaded at run time, using the Load method, the application's configuration file determines the dependencies that are loaded for the shared component — for example, the version of a dependency that is loaded. Le commutateur /ExeConfig donne à Ngen.exe des instructions sur les dépendances qui seraient chargées au moment de l'exécution.The /ExeConfig switch gives Ngen.exe guidance on which dependencies would be loaded at run time.
/AppBase: directoryPath/AppBase: directoryPath Lors de la localisation des dépendances, utilisez le répertoire spécifié comme base de l'application.When locating dependencies, use the specified directory as the application base.

OptionsOptions

OptionOption DescriptionDescription
/nologo Supprimer l'affichage de la bannière de démarrage Microsoft.Suppress the Microsoft startup banner display.
/silent Supprimer l'affichage des messages d'opération réussie.Suppress the display of success messages.
/verbose Afficher des informations détaillées sur le débogage.Display detailed information for debugging. Remarque : En raison des limitations du système d’exploitation, cette option n’affiche pas autant d’informations supplémentaires sur Windows 98 et sur Windows Millennium.Note: Due to operating system limitations, this option does not display as much additional information on Windows 98 and Windows Millennium Edition.
/help, /?/help, /? Afficher la syntaxe de commande et les options de la version actuelle.Display command syntax and options for the current release.

RemarquesRemarks

Pour exécuter Ngen.exe, vous devez disposer de privilèges d'administrateur.To run Ngen.exe, you must have administrative privileges.

Attention

N'exécutez pas Ngen.exe sur les assemblys dont le niveau de confiance n'est pas suffisant.Do not run Ngen.exe on assemblies that are not fully trusted. À compter de .NET Framework 4, Ngen.exe compile des assemblys avec une confiance totale et la stratégie de sécurité d’accès du code (CAS) n’est plus évaluée.Starting with the .NET Framework 4, Ngen.exe compiles assemblies with full trust, and code access security (CAS) policy is no longer evaluated.

À compter de .NET Framework 4, les images natives générées avec Ngen.exe ne peuvent plus être chargées dans les applications qui s’exécutent avec une confiance partielle.Starting with the .NET Framework 4, the native images that are generated with Ngen.exe can no longer be loaded into applications that are running in partial trust. À la place, le compilateur juste-à-temps (JIT) est appelé.Instead, the just-in-time (JIT) compiler is invoked.

Ngen.exe génère des images natives pour l'assembly spécifié par l’argument assemblyname passé à l’action install et toutes ses dépendances.Ngen.exe generates native images for the assembly specified by the assemblyname argument to the install action and all its dependencies. Les dépendances sont déterminées à partir de références du manifeste d'assembly.Dependencies are determined from references in the assembly manifest. Le seul scénario dans lequel vous devez installer une dépendance séparément est lorsque l'application la charge à l'aide de la réflexion, en appelant la méthode Assembly.Load par exemple.The only scenario in which you need to install a dependency separately is when the application loads it using reflection, for example by calling the Assembly.Load method.

Important

N'utilisez pas la méthode Assembly.LoadFrom avec les images natives.Do not use the Assembly.LoadFrom method with native images. Une image chargée avec cette méthode ne peut pas être utilisée par d'autres assemblys dans le contexte d'exécution.An image loaded with this method cannot be used by other assemblies in the execution context.

Ngen.exe conserve un décompte des dépendances.Ngen.exe maintains a count on dependencies. Par exemple, supposons que MyAssembly.exe et YourAssembly.exe sont installés tous les deux dans le cache des images natives et qu'ils contiennent tous les deux des références à OurDependency.dll.For example, suppose MyAssembly.exe and YourAssembly.exe are both installed in the native image cache, and both have references to OurDependency.dll. Si MyAssembly.exe est désinstallé, OurDependency.dll n'est pas désinstallée.If MyAssembly.exe is uninstalled, OurDependency.dll is not uninstalled. Il est supprimé uniquement lorsque YourAssembly.exe est également désinstallé.It is only removed when YourAssembly.exe is also uninstalled.

Si vous générez une image native pour un assembly dans le Global Assembly Cache, spécifiez son nom complet.If you are generating a native image for an assembly in the global assembly cache, specify its display name. Consultez Assembly.FullName.See Assembly.FullName.

Les images natives que Ngen.exe génère peuvent être partagées entre des domaines d'application.The native images that Ngen.exe generates can be shared across application domains. Cela signifie que vous ne pouvez pas utiliser Ngen.exe dans des scénarios d'application qui nécessitent que les assemblys soient partagés par des domaines d'application.This means you can use Ngen.exe in application scenarios that require assemblies to be shared across application domains. Pour spécifier la neutralité de domaine :To specify domain neutrality:

Utilisez toujours un code indépendant du domaine lors du chargement du même assembly dans plusieurs domaines d'application.Always use domain-neutral code when loading the same assembly into multiple application domains. Si une image native est chargée dans un domaine d'application non partagé après avoir été chargée dans un domaine partagé, elle ne peut pas être utilisée.If a native image is loaded into a nonshared application domain after having been loaded into a shared domain, it cannot be used.

Notes

Le code indépendant du domaine ne peut pas être déchargé et les performances peuvent être légèrement plus lentes, en particulier lors de l'accès aux membres statiques.Domain-neutral code cannot be unloaded, and performance may be slightly slower, particularly when accessing static members.

Dans cette section Notes :In this Remarks section:

Génération d'images dans différents scénariosGenerating images for different scenarios

Une fois que vous avez généré une image native pour un assembly, le runtime essaie automatiquement de la localiser et de l'utiliser chaque fois qu'il exécute l'assembly.After you have generated a native image for an assembly, the runtime automatically attempts to locate and use this native image each time it runs the assembly. Plusieurs images peuvent être générées, selon les scénarios d'utilisation.Multiple images can be generated, depending on usage scenarios.

Par exemple, si vous exécutez un assembly dans un scénario de débogage ou de profilage, le runtime recherche une image native générée à l'aide des options /Debug ou /Profile.For example, if you run an assembly in a debugging or profiling scenario, the runtime looks for a native image that was generated with the /Debug or /Profile options. S'il ne trouve pas d'image native correspondante, le runtime revient à la compilation JIT standard.If it is unable to find a matching native image, the runtime reverts to standard JIT compilation. La seule façon de déboguer des images natives consiste à créer une image native avec l'option /Debug.The only way to debug native images is to create a native image with the /Debug option.

L'action uninstall reconnaît également les scénarios, vous pouvez ainsi désinstaller tous les scénarios ou uniquement les scénarios sélectionnés.The uninstall action also recognize scenarios, so you can uninstall all scenarios or only selected scenarios.

Détermination des cas d'utilisation des images nativesDetermining when to Use native images

Les images natives peuvent fournir des améliorations des performances dans deux domaines : l'amélioration de l'utilisation de la mémoire et la réduction du temps de démarrage.Native images can provide performance improvements in two areas: improved memory use and reduced startup time.

Notes

Les performances des images natives dépendent de plusieurs facteurs qui rendent l'analyse difficile, tels que le code et les modèles d'accès aux données, le nombre d'appels effectués entre les limites de module et le nombre de dépendances déjà chargées par d'autres applications.Performance of native images depends on a number of factors that make analysis difficult, such as code and data access patterns, how many calls are made across module boundaries, and how many dependencies have already been loaded by other applications. La seule façon de déterminer si les images natives tirent parti de votre application consiste à effectuer des mesures de performances prudentes dans vos scénarios de déploiement clés.The only way to determine whether native images benefit your application is by careful performance measurements in your key deployment scenarios.

Amélioration de l'utilisation de la mémoireImproved memory use

Les images natives peuvent considérablement améliorer l'utilisation de la mémoire lorsque le code est partagé entre des processus.Native images can significantly improve memory use when code is shared between processes. Les images natives sont des fichiers PE Windows. Une seule copie d'un fichier .dll peut donc être partagée par plusieurs processus ; en revanche, le code natif produit par le compilateur JIT est stocké dans la mémoire privée et ne peut pas être partagé.Native images are Windows PE files, so a single copy of a .dll file can be shared by multiple processes; by contrast, native code produced by the JIT compiler is stored in private memory and cannot be shared.

Les applications qui sont exécutées sous des services Terminal Server peuvent également bénéficier de pages de code partagées.Applications that are run under terminal services can also benefit from shared code pages.

En outre, ne pas charger le compilateur JIT économise une quantité de mémoire fixe pour chaque instance d'application.In addition, not loading the JIT compiler saves a fixed amount of memory for each application instance.

Démarrage d'applications plus rapideFaster application startup

La précompilation des assemblys avec Ngen.exe peut améliorer le temps de démarrage de certaines applications.Precompiling assemblies with Ngen.exe can improve the startup time for some applications. En général, des progrès peuvent être réalisés lorsque les applications partagent des assemblys de composants, car après le démarrage de la première application, les composants partagés sont déjà chargés pour les applications suivantes.In general, gains can be made when applications share component assemblies because after the first application has been started the shared components are already loaded for subsequent applications. Le démarrage à froid, dans lequel tous les assemblys d'une application doivent être chargés à partir du disque dur, ne tire pas autant parti des images natives, car le temps d'accès au disque dur prédomine.Cold startup, in which all the assemblies in an application must be loaded from the hard disk, does not benefit as much from native images because the hard disk access time predominates.

La liaison matérielle peut affecter le temps de démarrage, car toutes les images qui sont liées par une liaison matérielle à l'assembly d'application principale doivent être chargées en même temps.Hard binding can affect startup time, because all images that are hard bound to the main application assembly must be loaded at the same time.

Notes

Avant .NET Framework 3.5 Service Pack 1, vous devez mettre les composants partagés avec nom fort dans le Global Assembly Cache, étant donné que le chargeur exécute une validation supplémentaire sur les assemblys avec nom fort qui ne sont pas dans le Global Assembly Cache, en éliminant efficacement toute amélioration du temps de démarrage gagné à l'aide des images natives.Before the .NET Framework 3.5 Service Pack 1, you should put shared, strong-named components in the global assembly cache, because the loader performs extra validation on strong-named assemblies that are not in the global assembly cache, effectively eliminating any improvement in startup time gained by using native images. Les optimisations présentées dans .NET Framework 3.5 SP1 ont supprimé la validation supplémentaire.Optimizations that were introduced in the .NET Framework 3.5 SP1 removed the extra validation.

Récapitulatif des considérations relatives à l'utilisationSummary of usage considerations

Les considérations générales suivantes et celles sur l'application peuvent vous aider à décider si cela vaut la peine d'évaluer des images natives pour votre application :The following general considerations and application considerations may assist you in deciding whether to undertake the effort of evaluating native images for your application:

  • Les images natives se chargent plus vite que MSIL, car elles ne nécessitent pas beaucoup d'activités de démarrage, comme la compilation JIT et la vérification de la sécurité de type.Native images load faster than MSIL because they eliminate the need for many startup activities, such as JIT compilation and type-safety verification.

  • Les images natives requièrent un jeu de travail initial réduit, car elles n'ont pas besoin d'un compilateur JIT.Native images require a smaller initial working set because there is no need for the JIT compiler.

  • Les images natives activent le partage de code entre les processus.Native images enable code sharing between processes.

  • Les images natives requièrent plus d'espace de disque dur que les assemblys MSIL et leur génération peut nécessiter beaucoup de temps.Native images require more hard disk space than MSIL assemblies and may require considerable time to generate.

  • Les images natives doivent être gérées.Native images must be maintained.

    • Elles doivent être régénérées lorsque l'assembly d'origine ou l'une de ses dépendances est pris(e) en charge.Images need to be regenerated when the original assembly or one of its dependencies is serviced.

    • Un seul assembly peut avoir besoin de plusieurs images natives pour les utiliser dans différentes applications ou différents scénarios.A single assembly may need multiple native images for use in different applications or different scenarios. Par exemple, les informations de configuration de deux applications peuvent donner lieu à des décisions différentes en matière de liaison pour le même assembly dépendant.For example, the configuration information in two applications might result in different binding decisions for the same dependent assembly.

    • Les images natives doivent être générées par un administrateur, c'est-à-dire à partir d'un compte Windows du groupe Administrateurs.Native images must be generated by an administrator; that is, from a Windows account in the Administrators group.

Outre ces considérations générales, la nature de votre application doit être prise en compte lorsque vous déterminez si les images natives peuvent fournir un gain de performances :In addition to these general considerations, the nature of your application must be considered when determining whether native images might provide a performance benefit:

  • Si votre application s'exécute dans un environnement qui utilise beaucoup de composants partagés, les images natives permettent aux composants d'être partagés entre plusieurs processus.If your application runs in an environment that uses many shared components, native images allow the components to be shared by multiple processes.

  • Si votre application utilise plusieurs domaines d'application, les images natives permettent à des pages de codes d'être partagées entre des domaines.If your application uses multiple application domains, native images allow code pages to be shared across domains.

    Notes

    Dans les versions 1.0 et 1.1 du .NET Framework, les images natives ne peuvent pas être partagées entre des domaines d'application.In the .NET Framework versions 1.0 and 1.1, native images cannot be shared across application domains. Ce n'est pas le cas dans les versions 2.0 et ultérieures.This is not the case in version 2.0 or later.

  • Si votre application est exécutée sous Terminal Server, les images natives autorisent le partage des pages de code.If your application will be run under Terminal Server, native images allow sharing of code pages.

  • Les applications volumineuses tirent généralement parti de la compilation dans des images natives.Large applications generally benefit from compilation to native images. Les petites applications n'en tirent généralement pas parti.Small applications generally do not benefit.

  • Pour les applications de longue durée, la compilation JIT à l'exécution est légèrement plus performante que les images natives.For long-running applications, run-time JIT compilation performs slightly better than native images. (La liaison matérielle peut atténuer cette différence de performances dans une certaine mesure.)(Hard binding can mitigate this performance difference to some degree.)

Importance des adresses de base d'assemblysImportance of assembly base addresses

Étant donné que les images natives sont des fichiers PE Windows, elles sont soumises aux mêmes problèmes de redéfinition que les autres fichiers exécutables.Because native images are Windows PE files, they are subject to the same rebasing issues as other executable files. Le coût du réadressage en termes de performances est encore plus marqué si la liaison matérielle est utilisée.The performance cost of relocation is even more pronounced if hard binding is employed.

Pour définir l'adresse de base d'une image native, utilisez l'option appropriée de votre compilateur pour définir l'adresse de base de l'assembly.To set the base address for a native image, use the appropriate option of your compiler to set the base address for the assembly. Ngen.exe utilise cette adresse de base pour l'image native.Ngen.exe uses this base address for the native image.

Notes

Les images natives sont plus volumineuses que les assemblys managés à partir desquels elles ont été créées.Native images are larger than the managed assemblies from which they were created. Les adresses de base doivent être calculées pour prendre en compte ces tailles plus grandes.Base addresses must be calculated to allow for these larger sizes.

Vous pouvez utiliser un outil tel que dumpbin.exe pour visualiser l'adresse de base par défaut d'une image native.You can use a tool such as dumpbin.exe to view the preferred base address of a native image.

Liaison matérielleHard binding

La liaison matérielle augmente le débit et réduit la taille du jeu de travail des images natives.Hard binding increases throughput and reduces working set size for native images. L'inconvénient de la liaison matérielle réside dans le fait que toutes les images liées par une liaison matérielle à un assembly doivent être chargées lorsque l'assembly est chargé.The disadvantage of hard binding is that all the images that are hard bound to an assembly must be loaded when the assembly is loaded. Cela peut augmenter considérablement le temps de démarrage d'une application volumineuse.This can significantly increase startup time for a large application.

La liaison matérielle convient aux dépendances qui sont chargées dans tous les scénarios de votre application dont les performances sont critiques.Hard binding is appropriate for dependencies that are loaded in all your application's performance-critical scenarios. Comme dans tous les aspects de l'utilisation des images natives, les mesures de performances prudentes constituent le seul moyen de déterminer si la liaison matérielle améliore les performances de votre application.As with any aspect of native image use, careful performance measurements are the only way to determine whether hard binding improves your application's performance.

Les attributs DependencyAttribute et DefaultDependencyAttribute vous permettent de fournir des indications sur la liaison matérielle à Ngen.exe.The DependencyAttribute and DefaultDependencyAttribute attributes allow you to provide hard binding hints to Ngen.exe.

Notes

Ces attributs sont des indications destinées à Ngen.exe et non des commandes.These attributes are hints to Ngen.exe, not commands. Leur utilisation ne garantit pas de liaison matérielle.Using them does not guarantee hard binding. La signification de ces attributs peut changer dans les versions ultérieures.The meaning of these attributes may change in future releases.

Spécification d’une indication sur la liaison d’une dépendanceSpecifying a binding hint for a dependency

Appliquez DependencyAttribute à un assembly pour indiquer la probabilité de chargement d'une dépendance spécifiée.Apply the DependencyAttribute to an assembly to indicate the likelihood that a specified dependency will be loaded. LoadHint.Always indique que la liaison matérielle est appropriée, Default indique que la valeur par défaut de la dépendance doit être utilisée et Sometimes indique que la liaison matérielle n'est pas appropriée.LoadHint.Always indicates that hard binding is appropriate, Default indicates that the default for the dependency should be used, and Sometimes indicates that hard binding is not appropriate.

Le code suivant affiche les attributs d'un assembly qui possède deux dépendances.The following code shows the attributes for an assembly that has two dependencies. La première dépendance (Assembly1) est un candidat approprié pour la liaison matérielle et la deuxième (Assembly2) ne l'est pas.The first dependency (Assembly1) is an appropriate candidate for hard binding, and the second (Assembly2) is not.

Imports System.Runtime.CompilerServices
<Assembly:DependencyAttribute("Assembly1", LoadHint.Always)>
<Assembly:DependencyAttribute("Assembly2", LoadHint.Sometimes)>
using System.Runtime.CompilerServices;
[assembly:DependencyAttribute("Assembly1", LoadHint.Always)]
[assembly:DependencyAttribute("Assembly2", LoadHint.Sometimes)]
using namespace System::Runtime::CompilerServices;
[assembly:DependencyAttribute("Assembly1", LoadHint.Always)];
[assembly:DependencyAttribute("Assembly2", LoadHint.Sometimes)];

Le nom de l'assembly n'inclut pas l'extension de nom de fichier.The assembly name does not include the file name extension. Les noms complets peuvent être utilisés.Display names can be used.

Spécification d’une indication sur la liaison par défaut d’un assemblySpecifying a default binding hint for an assembly

Les indications sur la liaison par défaut sont nécessaires uniquement pour les assemblys qui seront utilisés immédiatement et fréquemment par toute application qui possède une dépendance sur eux.Default binding hints are only needed for assemblies that will be used immediately and frequently by any application that has a dependency on them. Appliquez DefaultDependencyAttribute avec LoadHint.Always aux assemblys de ce type pour spécifier que la liaison matérielle doit être utilisée.Apply the DefaultDependencyAttribute with LoadHint.Always to such assemblies to specify that hard binding should be used.

Notes

Il est inutile d'appliquer DefaultDependencyAttribute aux assemblys .dll qui ne correspondent pas à cette catégorie, car l'application de l'attribut ayant une valeur autre que LoadHint.Always a le même effet que de ne pas appliquer l'attribut du tout.There is no reason to apply DefaultDependencyAttribute to .dll assemblies that do not fall into this category, because applying the attribute with any value other than LoadHint.Always has the same effect as not applying the attribute at all.

Microsoft utilise DefaultDependencyAttribute pour spécifier que la liaison matérielle est la valeur par défaut d'un très petit nombre d'assemblys dans le .NET Framework, tel que mscorlib.dll.Microsoft uses the DefaultDependencyAttribute to specify that hard binding is the default for a very small number of assemblies in the .NET Framework, such as mscorlib.dll.

Traitement différéDeferred processing

La génération d'images natives d'une application très volumineuse peut prendre beaucoup de temps.Generation of native images for a very large application can take considerable time. De même, les modifications apportées à un composant partagé ou aux paramètres de l'ordinateur peuvent nécessiter la mise à jour de nombreuses images natives.Similarly, changes to a shared component or changes to computer settings might require many native images to be updated. Les actions install et update possèdent une option /queue qui met en file d'attente l'opération en vue d'une exécution différée par le service d'images natives.The install and update actions have a /queue option that queues the operation for deferred execution by the native image service. En outre, Ngen.exe possède des actions queue et executeQueuedItems qui offrent un certain contrôle sur le service.In addition, Ngen.exe has queue and executeQueuedItems actions that provide some control over the service. Pour plus d'informations, consultez Service d'images natives.For more information, see Native Image Service.

Images natives et compilation JITNative images and JIT compilation

Si, dans un assembly, Ngen.exe rencontre des méthodes qu'il ne peut pas générer, il les exclut de l'image native.If Ngen.exe encounters any methods in an assembly that it cannot generate, it excludes them from the native image. Lorsque le runtime exécute cet assembly, il revient à la compilation JIT des méthodes non incluses dans l'image native.When the runtime executes this assembly, it reverts to JIT compilation for the methods that were not included in the native image.

En outre, les images natives ne sont pas utilisées si l'assembly a été mis à niveau ou si l'image a été invalidée pour une raison quelconque.In addition, native images are not used if the assembly has been upgraded, or if the image has been invalidated for any reason.

Images non validesInvalid images

Lorsque vous utilisez Ngen.exe pour créer une image native d'un assembly, le résultat dépend des options de ligne de commande spécifiées et de certains paramètres de votre ordinateur.When you use Ngen.exe to create a native image of an assembly, the output depends upon the command-line options that you specify and certain settings on your computer. Ces paramètres sont les suivants :These settings include the following:

  • Version du .NET Framework.The version of the .NET Framework.

  • Version du système d'exploitation, si vous passez de la famille Windows 9x à la famille Windows NT.The version of the operating system, if the change is from the Windows 9x family to the Windows NT family.

  • Identité exacte de l'assembly (toute nouvelle compilation modifie l'identité).The exact identity of the assembly (recompilation changes identity).

  • Identité exacte de tous les assemblys auxquels l'assembly fait référence (toute nouvelle compilation modifie l'identité).The exact identity of all assemblies that the assembly references (recompilation changes identity).

  • Facteurs de sécurité.Security factors.

Ngen.exe enregistre ces informations lorsqu'il génère une image native.Ngen.exe records this information when it generates a native image. Lorsque vous exécutez un assembly, le runtime recherche l'image native générée à l'aide des options et des paramètres correspondant à l'environnement actif de l'ordinateur.When you execute an assembly, the runtime looks for the native image generated with options and settings that match the computer's current environment. Le runtime revient à la compilation JIT d'un assembly, s'il ne trouve pas d'image native correspondante.The runtime reverts to JIT compilation of an assembly if it cannot find a matching native image. Les modifications suivantes des paramètres et de l'environnement d'un ordinateur entraînent la perte de validité des images natives :The following changes to a computer's settings and environment cause native images to become invalid:

  • Version du .NET Framework.The version of the .NET Framework.

    Si vous appliquez une mise à jour au .NET Framework, toutes les images natives que vous avez créées à l'aide de Ngen.exe deviennent non valides.If you apply an update to the .NET Framework, all native images that you have created using Ngen.exe become invalid. Pour cette raison, toutes les mises à jour du .NET Framework exécutent la commande Ngen Update, afin de s'assurer que toutes les images natives sont régénérées.For this reason, all updates of the .NET Framework execute the Ngen Update command, to ensure that all native images are regenerated. Le .NET Framework crée automatiquement de nouvelles images natives pour les bibliothèques .NET Framework qu'il installe.The .NET Framework automatically creates new native images for the .NET Framework libraries that it installs.

  • Version du système d'exploitation, si vous passez de la famille Windows 9x à la famille Windows NT.The version of the operating system, if the change is from the Windows 9x family to the Windows NT family.

    Par exemple, si la version du système d’exploitation s’exécutant sur un ordinateur passe de Windows 98 à Windows XP, toutes les images natives stockées dans le cache des images natives ne sont plus valides.For example, if the version of the operating system running on a computer changes from Windows 98 to Windows XP, all native images stored in the native image cache become invalid. Toutefois, si le système d’exploitation passe de Windows 2000 à Windows XP, les images restent valides.However, if the operating system changes from Windows 2000 to Windows XP, the images are not invalidated.

  • Identité exacte de l'assembly.The exact identity of the assembly.

    Si vous recompilez un assembly, l'image native correspondante de l'assembly devient non valide.If you recompile an assembly, the assembly's corresponding native image becomes invalid.

  • Identité exacte des assemblys auxquels l'assembly fait référence.The exact identity of any assemblies the assembly references.

    Si vous mettez à jour un assembly managé, toutes les images natives qui dépendent directement ou indirectement de cet assembly deviennent non valides et doivent être régénérées.If you update a managed assembly, all native images that directly or indirectly depend on that assembly become invalid and need to be regenerated. Cela inclut des références ordinaires et des dépendances liées par une liaison matérielle.This includes both ordinary references and hard-bound dependencies. Chaque fois qu'une mise à jour de logiciel est appliquée, le programme d'installation doit exécuter une commande Ngen Update pour garantir que toutes les images natives dépendantes sont régénérées.Whenever a software update is applied, the installation program should execute an Ngen Update command to ensure that all dependent native images are regenerated.

  • Facteurs de sécurité.Security factors.

    Le changement de stratégie de sécurité d'un ordinateur pour restreindre les autorisations précédemment accordées à un assembly peut entraîner la perte de validité d'une image native précédemment compilée de cet assembly.Changing machine security policy to restrict permissions previously granted to an assembly can cause a previously compiled native image for that assembly to become invalid.

    Pour plus d'informations sur la façon dont le Common Language Runtime administre la sécurité d'accès du code et sur l'utilisation des autorisations, consultez Sécurité d'accès du code.For detailed information about how the common language runtime administers code access security and how to use permissions, see Code Access Security.

Résolution des problèmesTroubleshooting

Les rubriques de résolution de problèmes suivantes vous permettent d’identifier les images natives qui sont utilisées par votre application et celles qui ne le peuvent pas, de déterminer quand le compilateur JIT commence à compiler une méthode, et montrent comment désactiver la compilation d’images natives des méthodes spécifiées.The following troubleshooting topics allow you to see which native images are being used and which cannot be used by your application, to determine when the JIT compiler starts to compile a method, and shows how to opt out of native image compilation of specified methods.

visionneuse du journal de liaison d’assemblyAssembly Binding Log Viewer

Pour confirmer que les images natives sont utilisées par votre application, vous pouvez utiliser Fuslogvw.exe (Visionneuse du journal de liaison d’assembly).To confirm that native images are being used by your application, you can use the Fuslogvw.exe (Assembly Binding Log Viewer). Sélectionnez Images natives dans la zone Catégories du journal dans la fenêtre de la visionneuse du journal des liaisons.Select Native Images in the Log Categories box on the binding log viewer window. Fuslogvw.exe fournit des informations sur la raison pour laquelle une image native a été rejetée.Fuslogvw.exe provides information about why a native image was rejected.

Assistant Débogage managé JITCompilationStartThe JITCompilationStart managed debugging assistant

Vous pouvez utiliser l'Assistant Débogage managé (MDA) JITCompilationStart pour déterminer quand le compilateur JIT commence à compiler une fonction.You can use the jitCompilationStart managed debugging assistant (MDA) to determine when the JIT compiler starts to compile a function.

Désactivation de la génération des images nativesOpting out of native image generation

Dans certains cas, NGen.exe peut avoir des difficultés à générer une image native pour une méthode spécifique, ou vous pouvez préférer que la méthode soit compilée par JIT et non compilée dans une image native.In some cases, NGen.exe may have difficulty generating a native image for a specific method, or you may prefer that the method be JIT compiled rather then compiled to a native image. Dans ce cas, vous pouvez utiliser l’attribut System.Runtime.BypassNGenAttribute pour éviter que NGen.exe génère une image native pour une méthode particulière.In this case, you can use the System.Runtime.BypassNGenAttribute attribute to prevent NGen.exe from generating a native image for a particular method. L’attribut doit être appliqué individuellement à chaque méthode dont vous ne voulez pas inclure le code dans l’image native.The attribute must be applied individually to each method whose code you do not want to include in the native image. NGen.exe reconnaît l’attribut et ne génère pas de code dans l’image native pour la méthode correspondante.NGen.exe recognizes the attribute and does not generate code in the native image for the corresponding method.

Toutefois, notez que BypassNGenAttribute n’est pas défini comme un type dans la bibliothèque de classes .NET Framework.Note, however, that BypassNGenAttribute is not defined as a type in the .NET Framework Class Library. Pour pouvoir utiliser l’attribut dans votre code, vous devez d’abord le définir de la façon suivante :In order to consume the attribute in your code, you must first define it as follows:

namespace System.Runtime
{
   [AttributeUsage(AttributeTargets.Method | 
                   AttributeTargets.Constructor | 
                   AttributeTargets.Property)]
   public class BypassNGenAttribute : Attribute 
   {
   }   
}
Namespace System.Runtime
   <AttributeUsage(AttributeTargets.Method Or 
                   AttributeTargets.Constructor Or 
                   AttributeTargets.Property)>
   Public Class BypassNGenAttribute : Inherits Attribute 
   End Class   
End Namespace

Vous pouvez ensuite appliquer l’attribut selon la méthode.You can then apply the attribute on a per-method basis. Dans l’exemple suivant, le générateur d’images natives reçoit l’instruction de ne pas générer d’image native pour la méthode ExampleClass.ToJITCompile.The following example instructs the Native Image Generator that it should not generate a native image for the ExampleClass.ToJITCompile method.

using System;
using System.Runtime;

public class ExampleClass
{
   [BypassNGen]
   public void ToJITCompile()
   {
   }
}
Imports System.Runtime

Public Class ExampleClass
   <BypassNGen>
   Public Sub ToJITCompile()
   End Sub
End Class

ExemplesExamples

La commande suivante génère une image native de ClientApp.exe, située dans le répertoire actif, puis installe l'image dans le cache des images natives.The following command generates a native image for ClientApp.exe, located in the current directory, and installs the image in the native image cache. S'il existe un fichier de configuration de l'assembly, Ngen.exe l'utilise.If a configuration file exists for the assembly, Ngen.exe uses it. En outre, les images natives sont générées pour tous les fichiers .dll auxquels ClientApp.exe fait référence.In addition, native images are generated for any .dll files that ClientApp.exe references.

ngen install ClientApp.exe

Une image installée avec Ngen.exe est également appelée une racine.An image installed with Ngen.exe is also called a root. Une racine peut être une application ou un composant partagé.A root can be an application or a shared component.

La commande suivante génère une image native de MyAssembly.exe en fonction du chemin d'accès spécifié.The following command generates a native image for MyAssembly.exe with the specified path.

ngen install c:\myfiles\MyAssembly.exe

Lors de la localisation des assemblys et de leurs dépendances, Ngen.exe utilise la même logique de détection que celle utilisée par le Common Language Runtime.When locating assemblies and their dependencies, Ngen.exe uses the same probing logic used by the common language runtime. Par défaut, le répertoire qui contient ClientApp.exe est utilisé comme répertoire de base de l'application et toute la recherche d'assemblys commence dans ce répertoire.By default, the directory that contains ClientApp.exe is used as the application base directory, and all assembly probing begins in this directory. Vous pouvez remplacer ce comportement en utilisant l'option /AppBase.You can override this behavior by using the /AppBase option.

Notes

Il s'agit là d'un changement par rapport au comportement de Ngen.exe dans les versions 1.0 et 1.1 du .NET Framework, dans lesquelles la base de l'application est définie sur le répertoire actif.This is a change from Ngen.exe behavior in the .NET Framework versions 1.0 and 1.1, where the application base is set to the current directory.

Un assembly peut posséder une dépendance sans référence, par exemple, s'il charge un fichier .dll en utilisant la méthode Assembly.Load.An assembly can have a dependency without a reference, for example if it loads a .dll file by using the Assembly.Load method. Vous pouvez créer une image native d'un fichier .dll de ce type en utilisant des informations de configuration de l'assembly d'application, avec l'option /ExeConfig.You can create a native image for such a .dll file by using configuration information for the application assembly, with the /ExeConfig option. La commande suivante génère une image native de MyLib.dll, à l'aide des informations de configuration de MyApp.exe.The following command generates a native image for MyLib.dll, using the configuration information from MyApp.exe.

ngen install c:\myfiles\MyLib.dll /ExeConfig:c:\myapps\MyApp.exe

Les assemblys installés grâce à cette méthode ne sont pas supprimés lorsque l'application est supprimée.Assemblies installed in this way are not removed when the application is removed.

Pour désinstaller une dépendance, utilisez les mêmes options de ligne de commande que celles qui ont servi à l'installer.To uninstall a dependency, use the same command-line options that were used to install it. La commande suivante désinstalle MyLib.dll de l'exemple précédent.The following command uninstalls the MyLib.dll from the previous example.

ngen uninstall c:\myfiles\MyLib.dll /ExeConfig:c:\myapps\MyApp.exe

Pour créer une image native d'un assembly dans le Global Assembly Cache, utilisez le nom complet de l'assembly.To create a native image for an assembly in the global assembly cache, use the display name of the assembly. Par exemple :For example:

ngen install "ClientApp, Version=1.0.0.0, Culture=neutral,
  PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL"

NGen.exe génère un ensemble d'images séparé pour chaque scénario que vous installez.NGen.exe generates a separate set of images for each scenario you install. Par exemple, les commandes suivantes installent un jeu complet d'images natives pour les opérations normales, un autre jeu complet pour le débogage et un troisième pour le profilage :For example, the following commands install a complete set of native images for normal operation, another complete set for debugging, and a third for profiling:

ngen install MyApp.exe
ngen install MyApp.exe /debug
ngen install MyApp.exe /profile

Affichage du cache des images nativesDisplaying the Native Image Cache

Une fois les images natives installées dans le cache, elles peuvent être affichées à l'aide de Ngen.exe.Once native images are installed in the cache, they can be displayed using Ngen.exe. La commande suivante affiche toutes les images natives du cache des images natives.The following command displays all native images in the native image cache.

ngen display

L'action display répertorie d'abord tous les assemblys racine, puis toutes les images natives sur l'ordinateur.The display action lists all the root assemblies first, followed by a list of all the native images on the computer.

Utilisez le nom simple d'un assembly pour afficher uniquement les informations de cet assembly.Use the simple name of an assembly to display information only for that assembly. La commande suivante affiche toutes les images natives dans le cache des images natives qui correspondent au nom partiel MyAssembly, leurs dépendances et toutes les racines qui ont une dépendance sur MyAssembly :The following command displays all native images in the native image cache that match the partial name MyAssembly, their dependencies, and all roots that have a dependency on MyAssembly:

ngen display MyAssembly

Connaître les racines qui dépendent d'un assembly de composant partagé est utile pour mesurer l'impact d'une action update après la mise à niveau du composant partagé.Knowing what roots depend on a shared component assembly is useful in gauging the impact of an update action after the shared component is upgraded.

Si vous spécifiez l’extension de fichier d’un assembly, vous devez spécifier le chemin d’accès ou exécuter Ngen.exe à partir du répertoire qui contient l’assembly :If you specify an assembly's file extension, you must either specify the path or execute Ngen.exe from the directory containing the assembly:

ngen display c:\myApps\MyAssembly.exe

La commande suivante affiche toutes les images natives du cache des images natives avec le nom MyAssembly et la version 1.0.0.0.The following command displays all native images in the native image cache with the name MyAssembly and the version 1.0.0.0.

ngen display "myAssembly, version=1.0.0.0"

Mise à jour d'imagesUpdating Images

Les images sont généralement mises à jour après la mise à niveau d'un composant partagé.Images are typically updated after a shared component has been upgraded. Pour mettre à jour toutes les images natives qui ont été modifiées ou dont les dépendances ont été modifiées, utilisez l'action update sans arguments.To update all native images that have changed, or whose dependencies have changed, use the update action with no arguments.

ngen update

La mise à jour de toutes les images peut prendre du temps.Updating all images can be a lengthy process. Vous pouvez mettre en file d'attente les mises à jour pour une exécution par le service d'images natives en utilisant l'option /queue.You can queue the updates for execution by the native image service by using the /queue option. Pour plus d'informations sur l'option /queue et les priorités d'installation, consultez Service d'images natives.For more information on the /queue option and installation priorities, see Native Image Service.

ngen update /queue

Désinstallation d'imagesUninstalling Images

Ngen.exe gère une liste de dépendances, de sorte que les composants partagés soient supprimés uniquement lorsque tous les assemblys qui dépendent d'eux ont été supprimés.Ngen.exe maintains a list of dependencies, so that shared components are removed only when all assemblies that depend on them have been removed. En outre, un composant partagé n'est pas supprimé s'il a été installé comme racine.In addition, a shared component is not removed if it has been installed as a root.

La commande suivante désinstalle tous les scénarios de ClientApp.exe racine :The following command uninstalls all scenarios for the root ClientApp.exe:

ngen uninstall ClientApp

L'action uninstall peut être utilisée pour supprimer des scénarios spécifiques.The uninstall action can be used to remove specific scenarios. La commande suivante désinstalle tous les scénarios de débogage de ClientApp.exe :The following command uninstalls all debug scenarios for ClientApp.exe:

ngen uninstall ClientApp /debug

Notes

La désinstallation de scénarios /debug ne désinstalle pas un scénario qui inclut /profile et /debug.Uninstalling /debug scenarios does not uninstall a scenario that includes both /profile and /debug.

La commande suivante désinstalle tous les scénarios d'une version spécifique de ClientApp.exe :The following command uninstalls all scenarios for a specific version of ClientApp.exe:

ngen uninstall "ClientApp, Version=1.0.0.0"

Les commandes suivantes désinstallent tous les scénarios de "ClientApp, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL", ou seulement le scénario de débogage de cet assembly :The following commands uninstall all scenarios for "ClientApp, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL", or just the debug scenario for that assembly:

ngen uninstall "ClientApp, Version=1.0.0.0, Culture=neutral,
  PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL"
ngen uninstall "ClientApp, Version=1.0.0.0, Culture=neutral,
  PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL" /debug

Comme avec l'action install, le fait de fournir une extension requiert d'exécuter Ngen.exe à partir du répertoire contenant l'assembly ou de spécifier un chemin d'accès complet.As with the install action, supplying an extension requires either executing Ngen.exe from the directory containing the assembly or specifying a full path.

Pour obtenir des exemples liés au service d'images natives, consultez Service d'images natives.For examples relating to the native image service, see Native Image Service.

Tâche d’image nativeNative Image Task

La tâche d'image native est une tâche Windows qui génère et conserve des images natives.The native image task is a Windows task that generates and maintains native images. La tâche d’image native génère et libère les images natives automatiquement pour les scénarios pris en charge.The native image task generates and reclaims native images automatically for supported scenarios. Elle permet aussi aux programmes d'installation d'utiliser Ngen.exe (Générateur d'images natives) pour créer et mettre à jour des images natives à un moment différé.It also enables installers to use Ngen.exe (Native Image Generator) to create and update native images at a deferred time.

La tâche d’image native est enregistrée une seule fois pour chaque architecture de processeur prise en charge sur un ordinateur, pour permettre la compilation des applications qui ciblent chaque architecture :The native image task is registered once for each CPU architecture supported on a computer, to allow compilation for applications that target each architecture:

Nom de la tâcheTask name Ordinateur 32 bits32-bit computer Ordinateur 64 bits64-bit computer
.NET Framework NGEN v4.0.30319NET Framework NGEN v4.0.30319 OuiYes OuiYes
NET Framework NGEN v4.0.30319 64NET Framework NGEN v4.0.30319 64 NonNo OuiYes

La tâche d’image native est disponible dans le .NET Framework 4.5 et versions ultérieures, dans le cadre d’une exécution sur Windows 8 ou version ultérieure.The native image task is available in the .NET Framework 4.5 and later versions, when running on Windows 8 or later. Dans les versions antérieures de Windows, le .NET Framework utilise le Service d'images natives.On earlier versions of Windows, the .NET Framework uses the Native Image Service.

Durée de vie de la tâcheTask Lifetime

En général, le Planificateur de tâches Windows démarre la tâche d'image native chaque nuit quand l'ordinateur est inactif.In general, the Windows Task Scheduler starts the native image task every night when the computer is idle. La tâche recherche tout travail différé mis en attente par les programmes d'installation de l'application, toutes les demandes de mise à jour différée des images natives et toute création automatique d'images.The task checks for any deferred work that is queued by application installers, any deferred native image update requests, and any automatic image creation. La tâche termine les éléments de travail en attente, puis s'arrête.The task completes outstanding work items and then shuts down. Si l'ordinateur cesse d'être inactif alors que la tâche s'exécute, celle-ci s'arrête.If the computer stops being idle while the task is running, the task stops.

Vous pouvez également démarrer la tâche d'image native manuellement à l'aide de l'interface utilisateur du Planificateur de tâches ou via des appels manuels à NGen.exe.You can also start the native image task manually through the Task Scheduler UI or through manual calls to NGen.exe. Si la tâche est démarrée par le biais de ces méthodes, elle continue à s'exécuter quand l'ordinateur n'est plus inactif.If the task is started through either of these methods, it will continue running when the computer is no longer idle. Les images créées manuellement à l'aide de NGen.exe sont hiérarchisées pour activer un comportement prévisible pour les programmes d'installation de l'application.Images created manually by using NGen.exe are prioritized to enable predictable behavior for application installers.

Service d'images nativesNative Image Service

Le service d'images natives est un service Windows qui génère et conserve des images natives.The native image service is a Windows service that generates and maintains native images. Le service d'images natives permet au développeur de différer l'installation et la mise à jour d'images natives jusqu'au moment où l'ordinateur est inactif.The native image service allows the developer to defer the installation and update of native images to periods when the computer is idle.

Normalement, le service d'images natives est lancé par le programme d'installation d'une application ou mise à jour.Normally, the native image service is initiated by the installation program (installer) for an application or update. Pour les actions de priorité 3, le service s'exécute pendant que l'ordinateur est inactif.For priority 3 actions, the service executes during idle time on the computer. Le service enregistre son état et est capable de poursuivre après de multiples redémarrages si nécessaire.The service saves its state and is capable of continuing through multiple reboots if necessary. Plusieurs compilations d'images peuvent être mises en attente.Multiple image compilations can be queued.

Le service interagit également avec la commande Ngen.exe manuelle.The service also interacts with the manual Ngen.exe command. Les commandes manuelles sont prioritaires sur l'activité en arrière-plan.Manual commands take precedence over background activity.

Notes

Sur Windows Vista, le nom affiché pour le service d'images natives est « Microsoft.NET Framework NGEN v2.0.50727_X86 » ou « Microsoft.NET Framework NGEN v2.0.50727_X64 ».On Windows Vista, the name displayed for the native image service is "Microsoft.NET Framework NGEN v2.0.50727_X86" or "Microsoft.NET Framework NGEN v2.0.50727_X64". Sur toutes les versions antérieures de Microsoft Windows, le nom est « .NET Runtime Optimization Service v2.0.50727_X86 » ou « .NET Runtime Optimization Service v2.0.50727_X64 ».On all earlier versions of Microsoft Windows, the name is ".NET Runtime Optimization Service v2.0.50727_X86" or ".NET Runtime Optimization Service v2.0.50727_X64".

Lancement d'opérations différéesLaunching Deferred Operations

Avant de commencer une installation ou une mise à niveau, il est recommandé d'interrompre le service.Before beginning an installation or upgrade, pausing the service is recommended. Cette interruption garantit que le service ne s'exécute pas pendant que le programme d'installation copie des fichiers ou place des assemblys dans le Global Assembly Cache.This ensures that the service does not execute while the installer is copying files or putting assemblies in the global assembly cache. La ligne de commande Ngen.exe suivante interrompt le service :The following Ngen.exe command line pauses the service:

ngen queue pause

Quand toutes les opérations différées ont été mises en attente, la commande suivante autorise le service à reprendre :When all deferred operations have been queued, the following command allows the service to resume:

ngen queue continue

Pour différer la génération d'images natives lors de l'installation d'une nouvelle application ou lors de la mise à jour d'un composant partagé, utilisez l'option /queue avec les actions install ou update.To defer native image generation when installing a new application or when updating a shared component, use the /queue option with the install or update actions. Les lignes de commande Ngen.exe suivantes installent une image native pour un composant partagé et effectuent une mise à jour de toutes les racines éventuellement affectées :The following Ngen.exe command lines install a native image for a shared component and perform an update of all roots that may have been affected:

ngen install MyComponent /queue
ngen update /queue

L'action update régénère toutes les images natives qui ont été invalidées, pas uniquement celles qui utilisent MyComponent.The update action regenerates all native images that have been invalidated, not just those that use MyComponent.

Si votre application se compose de nombreuses racines, vous pouvez contrôler la priorité des actions différées.If your application consists of many roots, you can control the priority of the deferred actions. Les commandes suivantes mettent en file d'attente l'installation de trois racines.The following commands queue the installation of three roots. Assembly1 est installé en premier, sans attendre l'inactivité.Assembly1 is installed first, without waiting for idle time. Assembly2 est également installé sans attendre l'inactivité, mais une fois que toutes les actions de priorité 1 sont terminées.Assembly2 is also installed without waiting for idle time, but after all priority 1 actions have completed. Assembly3 est installé quand le service détecte que l'ordinateur est inactif.Assembly3 is installed when the service detects that the computer is idle.

ngen install Assembly1 /queue:1
ngen install Assembly2 /queue:2
ngen install Assembly3 /queue:3

Vous pouvez forcer des actions mises en file d'attente à se produire de façon synchrone à l'aide de l'action executeQueuedItems.You can force queued actions to occur synchronously by using the executeQueuedItems action. Si vous fournissez la priorité facultative, cette action affecte uniquement les actions mises en file d'attente qui ont une priorité égale ou inférieure.If you supply the optional priority, this action affects only the queued actions that have equal or lower priority. La priorité par défaut est 3, donc la commande Ngen.exe suivante traite toutes les actions mises en file d'attente immédiatement et ne retourne pas de résultat tant qu'elles ne sont pas terminées :The default priority is 3, so the following Ngen.exe command processes all queued actions immediately, and does not return until they are finished:

ngen executeQueuedItems

Les commandes synchrones sont exécutées par Ngen.exe et n'utilisent pas le service d'images natives.Synchronous commands are executed by Ngen.exe and do not use the native image service. Vous pouvez exécuter des actions à l'aide de Ngen.exe pendant que le service d'images natives s'exécute.You can execute actions using Ngen.exe while the native image service is running.

Arrêt du serviceService Shutdown

Après avoir été initialisé par l'exécution d'une commande Ngen.exe qui inclut l'option /queue, le service s'exécute en arrière-plan jusqu'à ce que toutes les actions aient été effectuées.After being initiated by the execution of an Ngen.exe command that includes the /queue option, the service runs in the background until all actions have been completed. Le service enregistre son état pour pouvoir continuer via de multiples redémarrages si nécessaire.The service saves its state so that it can continue through multiple reboots if necessary. Quand le service détecte qu'il n'y aucune action en attente, il réinitialise son état afin de ne pas redémarrer la prochaine fois que l'ordinateur est démarré, puis il s'arrête.When the service detects that there are no more actions queued, it resets its status so that it will not restart the next time the computer is booted, and then it shuts itself down.

Interaction du service avec les clientsService Interaction with Clients

Dans le .NET Framework version 2.0, la seule interaction avec le service d'images natives s'effectue via l'outil en ligne de commande Ngen.exe.In the .NET Framework version 2.0, the only interaction with the native image service is through the command-line tool Ngen.exe. Utilisez l'outil en ligne de commande dans les scripts d'installation pour mettre en file d'attente des actions pour le service d'images natives et interagir avec le service.Use the command-line tool in installation scripts to queue actions for the native image service and to interact with the service.

Voir aussiSee also