Compartir por

Ngen.exe (Generador de imágenes nativas)

Native Image Generator (Ngen.exe) es una herramienta que mejora el rendimiento de las aplicaciones administradas. Ngen.exe crea imágenes nativas, que son archivos que contienen código de máquina específico del procesador compilado e los instala en la caché de imágenes nativas en el equipo local. El tiempo de ejecución puede usar imágenes nativas de la memoria caché en lugar de usar el compilador Just-In-Time (JIT) para compilar el ensamblado original.

Nota:

Ngen.exe compila imágenes nativas solo para ensamblados que tienen como destino .NET Framework. El generador de imágenes nativas equivalente para .NET Core es CrossGen.

Cambios en Ngen.exe en .NET Framework 4:

  • Ngen.exe ahora compila ensamblados con plena confianza y ya no se evalúa la directiva de seguridad de acceso a código (CAS).

  • Las imágenes nativas generadas con Ngen.exe ya no se pueden cargar en aplicaciones que se ejecutan en confianza parcial.

Cambios en Ngen.exe en .NET Framework versión 2.0:

  • La instalación de un ensamblado también instala sus dependencias, lo que simplifica la sintaxis de Ngen.exe.

  • Las imágenes nativas ahora se pueden compartir entre dominios de aplicación.

  • Una nueva acción, update, vuelve a crear imágenes que se han invalidado.

  • Las acciones se pueden aplazar para su ejecución mediante un servicio que usa tiempo de inactividad en el equipo para generar e instalar imágenes.

  • Se han eliminado algunas causas de invalidación de imágenes.

En Windows 8, consulta Native Image Task.

Para obtener información adicional sobre el uso de Ngen.exe y el servicio de imágenes nativas, consulte Native Image Service.

Nota:

Ngen.exe sintaxis para las versiones 1.0 y 1.1 de .NET Framework se pueden encontrar en Generador de imágenes nativas (Ngen.exe) Sintaxis heredada.

Esta herramienta se instala automáticamente con Visual Studio. Para ejecutar la herramienta, use el símbolo del sistema para desarrolladores de Visual Studio o Visual Studio Developer PowerShell.

En el símbolo del sistema, escriba lo siguiente:

Syntax

ngen action [options]

ngen /? | /help

Acciones

En la tabla siguiente se muestra la sintaxis de cada action. Para obtener descripciones de las partes individuales de , actionvea las tablas Argumentos, Niveles de prioridad, Escenarios y Configuración . En la tabla Opciones se describen los options modificadores de ayuda y .

Acción Description
install[] [scenariosassemblyPathassemblyName | ] [config] [/queue[{13:|2|}]] Genere imágenes nativas para un ensamblado y sus dependencias e instale las imágenes en la caché de imágenes nativas.

Si /queue se especifica , la acción se pone en cola para el servicio de imágenes nativas. La prioridad predeterminada es 3. Consulte la tabla Niveles de prioridad .
uninstall[] [assemblyNamescenarios | assemblyPath] []config Elimine las imágenes nativas de un ensamblado y sus dependencias de la caché de imágenes nativas.

Para desinstalar una sola imagen y sus dependencias, use los mismos argumentos de línea de comandos que se usaron para instalar la imagen. Nota: A partir de .NET Framework 4, la acción uninstall * ya no se admite.
update [/queue] Actualice las imágenes nativas que se han convertido en no válidas.

Si /queue se especifica , las actualizaciones se ponen en cola para el servicio de imágenes nativas. Las actualizaciones siempre se programan con prioridad 3, por lo que se ejecutan cuando el equipo está inactivo.
display [assemblyName | assemblyPath] Muestra el estado de las imágenes nativas de un ensamblado y sus dependencias.

Si no se proporciona ningún argumento, se muestra todo en la caché de imágenes nativas.
executeQueuedItems [1|2|3]

O bien:

eqi [1|2|3]		 Ejecutar trabajos de compilación en cola.

Si se especifica una prioridad, se ejecutan trabajos de compilación con mayor o igual prioridad. Si no se especifica ninguna prioridad, se ejecutan todos los trabajos de compilación en cola.
queue{pause | | continuestatus} Pause el servicio de imagen nativa, permita que el servicio en pausa continúe o consulte el estado del servicio.

Arguments

Argument Description
assemblyName Nombre para mostrar completo del ensamblado. Por ejemplo: "myAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0038abc9deabfle5". Nota: Puede proporcionar un nombre de ensamblado parcial, como myAssembly, para las display acciones y uninstall .

Solo se puede especificar un ensamblado por Ngen.exe línea de comandos.
assemblyPath Ruta de acceso explícita del ensamblado. Puede especificar una ruta de acceso completa o relativa.

Si especifica un nombre de archivo sin una ruta de acceso, el ensamblado debe encontrarse en el directorio actual.

Solo se puede especificar un ensamblado por Ngen.exe línea de comandos.

Niveles de prioridad

Priority Description
1 Las imágenes nativas se generan e instalan inmediatamente, sin esperar a tiempo de inactividad.
2 Las imágenes nativas se generan e instalan sin esperar a tiempo de inactividad, pero después de que se hayan completado todas las acciones de prioridad 1 (y sus dependencias).
3 Las imágenes nativas se instalan cuando el servicio de imágenes nativas detecta que el equipo está inactivo. Consulte Native Image Service.

Escenarios

Scenario Description
/Debug Genere imágenes nativas que se pueden usar en un depurador.
/Profile Genere imágenes nativas que se pueden usar en un generador de perfiles.
/NoDependencies Genere el número mínimo de imágenes nativas requeridas por las opciones de escenario especificadas.

Config

Configuración Description
/ExeConfig: exePath Use la configuración del ensamblado ejecutable especificado.

Ngen.exe debe tomar las mismas decisiones que el cargador al enlazar a dependencias. Cuando se carga un componente compartido en tiempo de ejecución, mediante el Load método , el archivo de configuración de la aplicación determina las dependencias que se cargan para el componente compartido; por ejemplo, la versión de una dependencia que se carga. El /ExeConfig modificador proporciona Ngen.exe instrucciones sobre qué dependencias se cargarían en tiempo de ejecución.
/AppBase: directoryPath Al buscar dependencias, use el directorio especificado como base de la aplicación.

Options

Opción Description
/nologo Suprima la presentación del banner de inicio de Microsoft.
/silent Suprima la presentación de mensajes correctos.
/verbose Mostrar información detallada para la depuración.
/help, /? Mostrar la sintaxis y las opciones de los comandos de la versión actual.

Observaciones

Para ejecutar Ngen.exe, debe tener privilegios administrativos.

Precaución

No ejecute Ngen.exe en ensamblados que no sean de plena confianza. A partir de .NET Framework 4, Ngen.exe compila ensamblados con plena confianza y ya no se evalúa la directiva de seguridad de acceso a código (CAS).

A partir de .NET Framework 4, las imágenes nativas que se generan con Ngen.exe ya no se pueden cargar en aplicaciones que se ejecutan en confianza parcial. En su lugar, se invoca el compilador Just-In-Time (JIT).

Ngen.exe genera imágenes nativas para el ensamblado especificado por el assemblyname argumento para la install acción y todas sus dependencias. Las dependencias se determinan a partir de referencias en el manifiesto del ensamblado. El único escenario en el que necesita instalar una dependencia por separado es cuando la aplicación la carga mediante reflexión, por ejemplo, llamando al Assembly.Load método .

Importante

No use el Assembly.LoadFrom método con imágenes nativas. Otros ensamblados no pueden usar una imagen cargada con este método en el contexto de ejecución.

Ngen.exe mantiene un recuento de dependencias. Por ejemplo, supongamos que MyAssembly.exe y YourAssembly.exe están instalados en la caché de imágenes nativas y ambos tienen referencias a OurDependency.dll. Si MyAssembly.exe se desinstala, OurDependency.dll no se desinstala. Solo se quita cuando YourAssembly.exe también se desinstala.

Si va a generar una imagen nativa para un ensamblado en la caché global de ensamblados, especifique su nombre para mostrar. Consulte Assembly.FullName.

Las imágenes nativas que Ngen.exe genera se pueden compartir entre dominios de aplicación. Esto significa que puede usar Ngen.exe en escenarios de aplicación que requieren que los ensamblados se compartan entre dominios de aplicación. Para especificar la neutralidad del dominio:

Use siempre código neutro en el dominio al cargar el mismo ensamblado en varios dominios de aplicación. Si una imagen nativa se carga en un dominio de aplicación no compartido después de haberse cargado en un dominio compartido, no se puede usar.

Nota:

El código neutro del dominio no se puede descargar y el rendimiento puede ser ligeramente más lento, especialmente cuando se accede a miembros estáticos.

En esta sección Comentarios:

Generación de imágenes para diferentes escenarios

Después de haber generado una imagen nativa para un ensamblado, el tiempo de ejecución intenta localizar y usar esta imagen nativa cada vez que ejecuta el ensamblado. Se pueden generar varias imágenes, en función de los escenarios de uso.

Por ejemplo, si ejecuta un ensamblado en un escenario de depuración o generación de perfiles, el entorno de ejecución busca una imagen nativa que se generó con las /Debug opciones o /Profile . Si no encuentra una imagen nativa coincidente, el tiempo de ejecución vuelve a la compilación JIT estándar. La única manera de depurar imágenes nativas es crear una imagen nativa con la /Debug opción .

La uninstall acción también reconoce escenarios, por lo que puede desinstalar todos los escenarios o solo los escenarios seleccionados.

Determinar cuándo usar imágenes nativas

Las imágenes nativas pueden proporcionar mejoras de rendimiento en dos áreas: uso mejorado de memoria y menor tiempo de inicio.

Nota:

El rendimiento de las imágenes nativas depende de varios factores que dificultan el análisis, como los patrones de acceso a código y datos, cuántas llamadas se realizan a través de los límites del módulo y cuántas dependencias ya han cargado otras aplicaciones. La única manera de determinar si las imágenes nativas benefician a la aplicación es mediante medidas de rendimiento cuidadosas en los escenarios clave de implementación.

Uso mejorado de memoria

Las imágenes nativas pueden mejorar significativamente el uso de memoria cuando el código se comparte entre procesos. Las imágenes nativas son archivos de Windows PE, por lo que varios procesos pueden compartir una sola copia de un archivo .dll; Por el contrario, el código nativo generado por el compilador JIT se almacena en memoria privada y no se puede compartir.

Las aplicaciones que se ejecutan en servicios de terminal también pueden beneficiarse de páginas de códigos compartidas.

Además, no cargar el compilador JIT guarda una cantidad fija de memoria para cada instancia de aplicación.

Inicio más rápido de la aplicación

La precompilación de ensamblados con Ngen.exe puede mejorar el tiempo de inicio de algunas aplicaciones. En general, se pueden obtener mejoras cuando las aplicaciones comparten ensamblados de componentes porque una vez iniciada la primera aplicación, los componentes compartidos ya se cargan para las aplicaciones posteriores. El inicio en frío, en el que todos los ensamblados de una aplicación deben cargarse desde el disco duro, no se beneficia tanto de las imágenes nativas porque el tiempo de acceso al disco duro predomina.

El enlace duro puede afectar al tiempo de inicio, ya que todas las imágenes que están enlazadas de forma difícil al ensamblado de aplicación principal deben cargarse al mismo tiempo.

Nota:

Antes de .NET Framework 3.5 Service Pack 1, debe colocar componentes compartidos con nombre seguro en la caché global de ensamblados, ya que el cargador realiza una validación adicional en ensamblados con nombre seguro que no están en la caché global de ensamblados, lo que elimina eficazmente cualquier mejora en el tiempo de inicio obtenido mediante imágenes nativas. Las optimizaciones que se introdujeron en .NET Framework 3.5 SP1 quitaron la validación adicional.

Resumen de las consideraciones de uso

Las siguientes consideraciones generales y consideraciones de aplicación pueden ayudarle a decidir si se debe realizar el esfuerzo de evaluar imágenes nativas para la aplicación:

  • Las imágenes nativas se cargan más rápido que CIL porque eliminan la necesidad de muchas actividades de inicio, como la compilación JIT y la comprobación de seguridad de tipos.

  • Las imágenes nativas requieren un conjunto de trabajo inicial más pequeño porque no es necesario el compilador JIT.

  • Las imágenes nativas permiten compartir código entre procesos.

  • Las imágenes nativas requieren más espacio en disco duro que los ensamblados CIL y pueden requerir un tiempo considerable para generar.

  • Las imágenes nativas deben mantenerse.

    • Las imágenes deben volver a generarse cuando se realiza el ensamblado original o una de sus dependencias.

    • Un único ensamblado puede necesitar varias imágenes nativas para su uso en diferentes aplicaciones o escenarios diferentes. Por ejemplo, la información de configuración de dos aplicaciones podría dar lugar a decisiones de enlace diferentes para el mismo ensamblado dependiente.

    • Un administrador debe generar imágenes nativas; es decir, desde una cuenta de Windows en el grupo Administradores.

Además de estas consideraciones generales, se debe tener en cuenta la naturaleza de la aplicación al determinar si las imágenes nativas pueden proporcionar una ventaja de rendimiento:

  • Si la aplicación se ejecuta en un entorno que usa muchos componentes compartidos, las imágenes nativas permiten que varios procesos compartan los componentes.

  • Si la aplicación usa varios dominios de aplicación, las imágenes nativas permiten que las páginas de códigos se compartan entre dominios.

    Nota:

    En las versiones 1.0 y 1.1 de .NET Framework, las imágenes nativas no se pueden compartir entre dominios de aplicación. Este no es el caso en la versión 2.0 o posterior.

  • Si la aplicación se ejecutará en Terminal Server, las imágenes nativas permiten compartir páginas de códigos.

  • Las aplicaciones grandes suelen beneficiarse de la compilación a las imágenes nativas. Por lo general, las aplicaciones pequeñas no se benefician.

  • En el caso de las aplicaciones de larga duración, la compilación JIT en tiempo de ejecución funciona ligeramente mejor que las imágenes nativas. (El enlace duro puede mitigar esta diferencia de rendimiento en algún grado).

Importancia de las direcciones base de ensamblado

Dado que las imágenes nativas son archivos de Windows PE, están sujetas a los mismos problemas de rebasificación que otros archivos ejecutables. El costo de rendimiento de la reubicación es aún más pronunciado si se emplea el enlace duro.

Para establecer la dirección base de una imagen nativa, use la opción adecuada del compilador para establecer la dirección base del ensamblado. Ngen.exe usa esta dirección base para la imagen nativa.

Nota:

Las imágenes nativas son mayores que los ensamblados administrados desde los que se crearon. Las direcciones base deben calcularse para permitir estos tamaños mayores.

Puede usar una herramienta como dumpbin.exe para ver la dirección base preferida de una imagen nativa.

Enlace duro

El enlace duro aumenta el rendimiento y reduce el tamaño del conjunto de trabajo para las imágenes nativas. La desventaja del enlace duro es que todas las imágenes que están enlazadas de forma difícil a un ensamblado deben cargarse cuando se carga el ensamblado. Esto puede aumentar significativamente el tiempo de inicio de una aplicación grande.

El enlace duro es adecuado para las dependencias que se cargan en todos los escenarios críticos para el rendimiento de la aplicación. Al igual que con cualquier aspecto del uso de imágenes nativas, las medidas de rendimiento cuidadosas son la única manera de determinar si el enlace duro mejora el rendimiento de la aplicación.

Los DependencyAttribute atributos y DefaultDependencyAttribute permiten proporcionar sugerencias de enlace duro para Ngen.exe.

Nota:

Estos atributos son sugerencias para Ngen.exe, no comandos. El uso de ellos no garantiza el enlace duro. El significado de estos atributos puede cambiar en futuras versiones.

Especificar una sugerencia de enlace para una dependencia

Aplique a DependencyAttribute un ensamblado para indicar la probabilidad de que se cargue una dependencia especificada. LoadHint.Always indica que el enlace duro es adecuado, Default indica que se debe usar el valor predeterminado para la dependencia e Sometimes indica que el enlace duro no es adecuado.

En el código siguiente se muestran los atributos de un ensamblado que tiene dos dependencias. La primera dependencia (Assembly1) es un candidato adecuado para el enlace duro y el segundo (Assembly2) no.

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)];

El nombre del ensamblado no incluye la extensión de nombre de archivo. Se pueden usar nombres para mostrar.

Especificar una sugerencia de enlace predeterminada para un ensamblado

Las sugerencias de enlace predeterminadas solo son necesarias para los ensamblados que se usarán inmediatamente y con frecuencia en cualquier aplicación que tenga una dependencia de ellos. Aplique con DefaultDependencyAttributeLoadHint.Always a estos ensamblados para especificar que se debe usar el enlace duro.

Nota:

No hay ninguna razón para aplicar DefaultDependencyAttribute a .dll ensamblados que no se encuentran en esta categoría, ya que aplicar el atributo con ningún valor distinto de LoadHint.Always tiene el mismo efecto que no aplicar el atributo en absoluto.

Microsoft usa DefaultDependencyAttribute para especificar que el enlace duro es el valor predeterminado para un número muy pequeño de ensamblados en .NET Framework, como mscorlib.dll.

Procesamiento diferido

La generación de imágenes nativas para una aplicación muy grande puede tardar mucho tiempo. De forma similar, los cambios en un componente compartido o los cambios en la configuración del equipo pueden requerir que se actualicen muchas imágenes nativas. Las install acciones y update tienen una /queue opción que pone en cola la operación para la ejecución diferida por el servicio de imágenes nativas. Además, Ngen.exe tiene queue acciones y executeQueuedItems que proporcionan cierto control sobre el servicio. Para obtener más información, consulte Native Image Service.

Imágenes nativas y compilación JIT

Si Ngen.exe encuentra métodos en un ensamblado que no puede generar, los excluye de la imagen nativa. Cuando el tiempo de ejecución ejecuta este ensamblado, se revierte a la compilación JIT para los métodos que no se incluyeron en la imagen nativa.

Además, las imágenes nativas no se usan si el ensamblado se ha actualizado o si la imagen se ha invalidado por cualquier motivo.

Imágenes no válidas

Cuando se usa Ngen.exe para crear una imagen nativa de un ensamblado, la salida depende de las opciones de línea de comandos que especifique y de ciertos valores en el equipo. Entre los ajustes se incluyen los siguientes:

  • Versión de .NET Framework.

  • La identidad exacta del ensamblado (la recompilación cambia la identidad).

  • La identidad exacta de todos los ensamblados a los que hace referencia el ensamblado (la recompilación cambia la identidad).

  • Factores de seguridad.

Ngen.exe registra esta información cuando genera una imagen nativa. Al ejecutar un ensamblado, el tiempo de ejecución busca la imagen nativa generada con opciones y configuraciones que coinciden con el entorno actual del equipo. El tiempo de ejecución se revierte a la compilación JIT de un ensamblado si no encuentra una imagen nativa coincidente. Los siguientes cambios en la configuración y el entorno de un equipo hacen que las imágenes nativas no sean válidas:

  • Versión de .NET Framework.

    Si aplica una actualización a .NET Framework, todas las imágenes nativas que ha creado con Ngen.exe no son válidas. Por este motivo, todas las actualizaciones de .NET Framework ejecutan el Ngen Update comando para asegurarse de que se vuelven a generar todas las imágenes nativas. .NET Framework crea automáticamente nuevas imágenes nativas para las bibliotecas de .NET Framework que instala.

  • Identidad exacta del ensamblado.

    Si vuelve a compilar un ensamblado, la imagen nativa correspondiente del ensamblado no es válida.

  • Identidad exacta de todos los ensamblados a los que hace referencia el ensamblado.

    Si actualiza un ensamblado administrado, todas las imágenes nativas que dependen directa o indirectamente de ese ensamblado no son válidas y deben volver a generarse. Esto incluye referencias normales y dependencias enlazadas de forma segura. Cada vez que se aplica una actualización de software, el programa de instalación debe ejecutar un Ngen Update comando para asegurarse de que se vuelven a generar todas las imágenes nativas dependientes.

  • Factores de seguridad.

    Cambiar la directiva de seguridad de la máquina para restringir los permisos concedidos previamente a un ensamblado puede hacer que una imagen nativa compilada previamente para ese ensamblado no sea válida.

    Para obtener información detallada sobre cómo Common Language Runtime administra la seguridad de acceso al código y cómo usar permisos, consulte Seguridad de acceso al código.

Solución de problemas

Los siguientes temas de solución de problemas permiten ver qué imágenes nativas se usan y cuáles no pueden usar la aplicación, para determinar cuándo el compilador JIT comienza a compilar un método y muestra cómo no participar en la compilación de imágenes nativas de los métodos especificados.

Visor de registros de enlaces de ensamblados

Para confirmar que la aplicación usa imágenes nativas, puede usar el Fuslogvw.exe (Visor de registros de enlace de ensamblados). Seleccione Imágenes nativas en el cuadro Categorías de registro en la ventana del visor de registros de enlace. Fuslogvw.exe proporciona información sobre por qué se rechazó una imagen nativa.

Asistente para depuración administrada JITCompilationStart

Puede usar el asistente para depuración administrada (MDA) jitCompilationStart para determinar cuándo comienza el compilador JIT a compilar una función.

No participar en la generación de imágenes nativas

En algunos casos, NGen.exe pueden tener dificultades para generar una imagen nativa para un método específico, o puede preferir que el método sea JIT compilado en lugar de compilarse en una imagen nativa. En este caso, puede usar el System.Runtime.BypassNGenAttribute atributo para evitar que NGen.exe genere una imagen nativa para un método determinado. El atributo se debe aplicar individualmente a cada método cuyo código no desee incluir en la imagen nativa. NGen.exe reconoce el atributo y no genera código en la imagen nativa para el método correspondiente.

Sin embargo, tenga en cuenta que BypassNGenAttribute no se define como un tipo en la biblioteca de clases de .NET Framework. Para consumir el atributo en el código, primero debe definirlo de la siguiente manera:

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

A continuación, puede aplicar el atributo por método. En el ejemplo siguiente se indica al generador de imágenes nativas que no debe generar una imagen nativa para el ExampleClass.ToJITCompile método .

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

Examples

El comando siguiente genera una imagen nativa para ClientApp.exe, ubicada en el directorio actual e instala la imagen en la caché de imágenes nativas. Si existe un archivo de configuración para el ensamblado, Ngen.exe lo usa. Además, las imágenes nativas se generan para cualquier archivo .dll que ClientApp.exe haga referencia.

ngen install ClientApp.exe

Una imagen instalada con Ngen.exe también se denomina raíz. Una raíz puede ser una aplicación o un componente compartido.

El siguiente comando genera una imagen nativa para MyAssembly.exe con la ruta de acceso especificada.

ngen install c:\myfiles\MyAssembly.exe

Al buscar ensamblados y sus dependencias, Ngen.exe usa la misma lógica de sondeo usada por Common Language Runtime. De forma predeterminada, el directorio que contiene ClientApp.exe se usa como directorio base de la aplicación y todo el sondeo de ensamblados comienza en este directorio. Puede invalidar este comportamiento mediante la /AppBase opción .

Nota:

Este es un cambio del comportamiento de Ngen.exe en las versiones 1.0 y 1.1 de .NET Framework, donde la base de la aplicación se establece en el directorio actual.

Un ensamblado puede tener una dependencia sin una referencia, por ejemplo, si carga un archivo .dll mediante el Assembly.Load método . Puede crear una imagen nativa para este .dll archivo mediante la información de configuración del ensamblado de la aplicación, con la /ExeConfig opción . El comando siguiente genera una imagen nativa para MyLib.dll usar la información de configuración de MyApp.exe.

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

Los ensamblados instalados de esta manera no se quitan cuando se quita la aplicación.

Para desinstalar una dependencia, use las mismas opciones de línea de comandos que se usaron para instalarla. El siguiente comando desinstala del MyLib.dll ejemplo anterior.

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

Para crear una imagen nativa para un ensamblado en la caché global de ensamblados, use el nombre para mostrar del ensamblado. Por ejemplo:

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

NGen.exe genera un conjunto independiente de imágenes para cada escenario que instale. Por ejemplo, los siguientes comandos instalan un conjunto completo de imágenes nativas para el funcionamiento normal, otro conjunto completo para la depuración y un tercero para la generación de perfiles:

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

Visualización de la caché de imágenes nativas

Una vez instaladas las imágenes nativas en la memoria caché, se pueden mostrar mediante Ngen.exe. El siguiente comando muestra todas las imágenes nativas en la caché de imágenes nativas.

ngen display

La display acción enumera primero todos los ensamblados raíz, seguido de una lista de todas las imágenes nativas del equipo.

Use el nombre simple de un ensamblado para mostrar información solo para ese ensamblado. El siguiente comando muestra todas las imágenes nativas de la memoria caché de imágenes nativas que coinciden con el nombre MyAssemblyparcial , sus dependencias y todas las raíces que tienen una dependencia de MyAssembly:

ngen display MyAssembly

Saber qué raíces dependen de un ensamblado de componente compartido es útil para calcular el impacto de una update acción después de actualizar el componente compartido.

Si especifica la extensión de archivo de un ensamblado, debe especificar la ruta de acceso o ejecutar Ngen.exe desde el directorio que contiene el ensamblado:

ngen display c:\myApps\MyAssembly.exe

El siguiente comando muestra todas las imágenes nativas de la caché de imágenes nativas con el nombre MyAssembly y la versión 1.0.0.0.

ngen display "myAssembly, version=1.0.0.0"

Actualización de imágenes

Las imágenes se actualizan normalmente después de actualizar un componente compartido. Para actualizar todas las imágenes nativas que han cambiado o cuyas dependencias han cambiado, use la update acción sin argumentos.

ngen update

La actualización de todas las imágenes puede ser un proceso largo. Puede poner en cola las actualizaciones para su ejecución por parte del servicio de imágenes nativas mediante la /queue opción . Para obtener más información sobre la /queue opción y las prioridades de instalación, consulte Native Image Service.

ngen update /queue

Desinstalación de imágenes

Ngen.exe mantiene una lista de dependencias, por lo que los componentes compartidos solo se quitan cuando se han quitado todos los ensamblados que dependen de ellos. Además, no se quita un componente compartido si se ha instalado como raíz.

El comando siguiente desinstala todos los escenarios de la raíz ClientApp.exe:

ngen uninstall ClientApp

La uninstall acción se puede usar para quitar escenarios específicos. El comando siguiente desinstala todos los escenarios de depuración para ClientApp.exe:

ngen uninstall ClientApp /debug

Nota:

La desinstalación de /debug escenarios no desinstala un escenario que incluye y /profile/debug.

El siguiente comando desinstala todos los escenarios de una versión específica de ClientApp.exe:

ngen uninstall "ClientApp, Version=1.0.0.0"

Los comandos siguientes desinstalan todos los escenarios de "ClientApp, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL", o simplemente el escenario de depuración para ese ensamblado:

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

Al igual que con la install acción, proporcionar una extensión requiere ejecutar Ngen.exe desde el directorio que contiene el ensamblado o especificar una ruta de acceso completa.

Para obtener ejemplos relacionados con el servicio de imágenes nativas, consulte Native Image Service.

Tarea Imagen nativa

La tarea de imagen nativa es una tarea de Windows que genera y mantiene imágenes nativas. La tarea de imagen nativa genera y reclama imágenes nativas automáticamente para escenarios admitidos. También permite a los instaladores usar Ngen.exe (Generador de imágenes nativas) para crear y actualizar imágenes nativas en un momento diferido.

La tarea de imagen nativa se registra una vez para cada arquitectura de CPU admitida en un equipo, para permitir la compilación de aplicaciones destinadas a cada arquitectura:

Nombre de tarea Equipo de 32 bits Equipo de 64 bits
NET Framework NGEN v4.0.30319 Sí Sí
NET Framework NGEN v4.0.30319 64 No Sí

La tarea de imagen nativa está disponible en .NET Framework 4.5 y versiones posteriores, cuando se ejecuta en Windows 8 o versiones posteriores. En versiones anteriores de Windows, .NET Framework usa native Image Service.

Duración de la tarea

En general, el Programador de tareas de Windows inicia la tarea de imagen nativa cada noche cuando el equipo está inactivo. La tarea comprueba si hay algún trabajo diferido en cola por los instaladores de aplicaciones, las solicitudes de actualización de imágenes nativas diferidas y cualquier creación automática de imágenes. La tarea completa los elementos de trabajo pendientes y, a continuación, se cierra. Si el equipo deja de estar inactivo mientras se ejecuta la tarea, la tarea se detiene.

También puede iniciar manualmente la tarea de imagen nativa a través de la interfaz de usuario del Programador de tareas o a través de llamadas manuales a NGen.exe. Si la tarea se inicia a través de cualquiera de estos métodos, seguirá ejecutándose cuando el equipo ya no esté inactivo. Las imágenes creadas manualmente mediante NGen.exe tienen prioridad para habilitar el comportamiento predecible para los instaladores de aplicaciones.

Servicio de imágenes nativas

El servicio de imágenes nativas es un servicio de Windows que genera y mantiene imágenes nativas. El servicio de imagen nativa permite al desarrollador aplazar la instalación y actualización de imágenes nativas a períodos en los que el equipo está inactivo.

Normalmente, el programa de instalación (instalador) inicia el servicio de imagen nativa para una aplicación o actualización. Para las acciones de prioridad 3, el servicio se ejecuta durante el tiempo de inactividad en el equipo. El servicio guarda su estado y es capaz de continuar con varios reinicios si es necesario. Se pueden poner en cola varias compilaciones de imágenes.

El servicio también interactúa con el comando manual Ngen.exe. Los comandos manuales tienen prioridad sobre la actividad en segundo plano.

Nota:

En Windows Vista, el nombre que se muestra para el servicio de imágenes nativas es "Microsoft.NET Framework NGEN v2.0.50727_X86" o "Microsoft.NET Framework NGEN v2.0.50727_X64". En todas las versiones anteriores de Microsoft Windows, el nombre es ".NET Runtime Optimization Service v2.0.50727_X86" o ".NET Runtime Optimization Service v2.0.50727_X64".

Inicio de operaciones diferidas

Antes de iniciar una instalación o actualización, se recomienda pausar el servicio. Esto garantiza que el servicio no se ejecute mientras el instalador copia archivos o coloca ensamblados en la caché global de ensamblados. El siguiente Ngen.exe línea de comandos detiene el servicio:

ngen queue pause

Cuando se han puesto en cola todas las operaciones diferidas, el siguiente comando permite que el servicio se reanude:

ngen queue continue

Para aplazar la generación de imágenes nativas al instalar una nueva aplicación o al actualizar un componente compartido, use la /queue opción con las install acciones o update . Los siguientes Ngen.exe líneas de comandos instalan una imagen nativa para un componente compartido y realizan una actualización de todas las raíces que pueden verse afectadas:

ngen install MyComponent /queue
ngen update /queue

La update acción vuelve a generar todas las imágenes nativas que se han invalidado, no solo las que usan MyComponent.

Si la aplicación consta de muchas raíces, puede controlar la prioridad de las acciones diferidas. Los siguientes comandos ponen en cola la instalación de tres raíces. Assembly1 se instala primero, sin esperar a tiempo de inactividad. Assembly2 también se instala sin esperar a tiempo de inactividad, pero después de que se hayan completado todas las acciones de prioridad 1. Assembly3 se instala cuando el servicio detecta que el equipo está inactivo.

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

Puede forzar que las acciones en cola se produzcan de forma sincrónica mediante la executeQueuedItems acción . Si proporciona la prioridad opcional, esta acción afecta solo a las acciones en cola que tienen una prioridad igual o menor. La prioridad predeterminada es 3, por lo que el siguiente comando Ngen.exe procesa todas las acciones en cola inmediatamente y no devuelve hasta que finalicen:

ngen executeQueuedItems

Los comandos sincrónicos se ejecutan mediante Ngen.exe y no usan el servicio de imagen nativa. Puede ejecutar acciones mediante Ngen.exe mientras se ejecuta el servicio de imágenes nativas.

Apagado del servicio

Después de iniciarse mediante la ejecución de un comando Ngen.exe que incluye la /queue opción , el servicio se ejecuta en segundo plano hasta que se hayan completado todas las acciones. El servicio guarda su estado para que pueda continuar con varios reinicios si es necesario. Cuando el servicio detecta que no hay más acciones en cola, restablece su estado para que no se reinicie la próxima vez que se arranque el equipo y, a continuación, se cierra.

Interacción del servicio con clientes

En .NET Framework versión 2.0, la única interacción con el servicio de imagen nativa es a través de la herramienta de línea de comandos Ngen.exe. Use la herramienta de línea de comandos en scripts de instalación para poner en cola las acciones del servicio de imágenes nativas e interactuar con el servicio.

Consulte también

  • Last updated on