Generador de imágenes nativas (Ngen.exe)
Actualización: noviembre 2007
El Generador de imágenes nativas (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 máquina específico del procesador compilado, e instala estas imágenes en la caché de imágenes nativas del equipo local. El motor en tiempo de ejecución puede utilizar las imágenes nativas de la caché en lugar de utilizar el compilador Just-In-Time (JIT) para compilar el ensamblado original.
Ngen.exe ha cambiado de forma significativa en la versión 2.0 de .NET Framework:
Al instalar un ensamblado, también se instalan sus dependencias, lo que simplifica la sintaxis de Ngen.exe.
Ahora, las imágenes nativas se pueden compartir en los dominios de aplicación.
Una nueva acción, update, vuelve a crear las imágenes invalidadas.
Es posible diferir las acciones, de modo que las ejecute un servicio que utilice el tiempo de inactividad del equipo para generar e instalar las imágenes.
Se han eliminado algunas de las causas de la invalidación de imágenes.
Para obtener información adicional sobre la forma de utilizar Ngen.exe y el servicio de imágenes nativas, vea Servicio de imágenes nativas.
Nota
Puede encontrar información sobre la sintaxis de Ngen.exe para las versiones 1.0 y 1.1 de .NET Framework en Sintaxis heredada del generador de imágenes nativas (Ngen.exe).
ngen <action> [options]
ngen /? | /help
Acciones
La tabla siguiente muestra la sintaxis de cada acción. Para consultar una descripción de los componentes individuales de actionArguments, vea las tablas Argumentos, Escenarios y Config. En la tabla Opciones se describe el parámetro options y los modificadores de ayuda.
Acción |
Descripción |
|---|---|
install [assemblyName | assemblyPath] [scenarios] [config] [/queue[:{1|2|3}]] |
Genera imágenes nativas para un ensamblado y sus dependencias e instala las imágenes en la caché de imágenes nativas. Si se especifica /queue, la acción se pone en la cola del servicio de imágenes nativas. El valor predeterminado para la prioridad es 3. |
uninstall [assemblyName | assemblyPath | *] [scenarios] [config] |
Elimina las imágenes nativas de un ensamblado y sus dependencias de la caché de imágenes nativas. Para desinstalar una imagen única y sus dependencias, utilice los mismos argumentos de la línea de comandos que utilizó para instalar la imagen. |
update [/queue] |
Actualiza las imágenes nativas que han dejado de ser válidas. Si se especifica /queue, las actualizaciones se colocan en la cola del servicio de imágenes nativas. Las actualizaciones siempre se programan con una prioridad de 3, por lo que se ejecutan cuando el equipo se encuentra inactivo. |
display [assemblyName | assemblyPath] |
Muestra el estado de las imágenes nativas para un ensamblado y sus dependencias. Si no se proporciona ningún argumento, se muestra todo el contenido de la caché de imágenes nativas. |
executeQueuedItems [1|2|3] |
Ejecuta los trabajos de compilación en cola. Si se especifica una prioridad, se ejecutan los trabajos de compilación con una prioridad mayor o igual a la especificada. Si no se especifica ninguna prioridad, se ejecutan todos los trabajos de compilación en cola. |
queue {pause | continue | status} |
Detiene el servicio imágenes nativas, permite la reanudación del servicio en pausa o consulta el estado del servicio. |
Argumentos
Argumento |
Descripción |
|---|---|
assemblyName |
Nombre completo para mostrar 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 acciones display y uninstall. Sólo se puede especificar un ensamblado por cada línea de comandos de Ngen.exe. |
assemblyPath |
Ruta de acceso explícita del ensamblado. Se puede especificar una ruta de acceso completa o relativa. Si se especifica un nombre de archivo sin una ruta de acceso, el ensamblado deberá estar ubicado en el directorio actual. Sólo se puede especificar un ensamblado por cada línea de comandos de Ngen.exe. |
Escenarios
Escenario |
Descripción |
|---|---|
/Debug |
Genera imágenes nativas que pueden utilizarse con un depurador. |
/Profile |
Genera imágenes nativas que pueden utilizarse con un generador de perfiles. |
/NoDependencies |
Genera el número mínimo de imágenes nativas exigido por las opciones de escenario especificadas. |
Config
Configuración |
Descripción |
|---|---|
/ExeConfig:exePath |
Utiliza la configuración del ensamblado ejecutable especificado. Ngen.exe tiene que tomar las mismas decisiones que el cargador al enlazarse a las dependencias. Cuando se carga un componente compartido en tiempo de ejecución, el uso del método Load permite que el archivo de configuración de la aplicación determine las dependencias que se cargan para el componente compartido como, por ejemplo, la versión que se carga de una dependencia. El modificador /ExeConfig proporciona a Ngen.exe una orientación sobre las dependencias que se cargarían en tiempo de ejecución. |
/AppBase:directoryPath |
Al buscar dependencias, utiliza el directorio especificado como base de la aplicación. |
Opciones
Opción |
Descripción |
|---|---|
/nologo |
Suprime la presentación de la pancarta de inicio de Microsoft. |
/silent |
Suprime la presentación de mensajes de operaciones correctas. |
/verbose |
Muestra información detallada para depurar. Nota Debido a las limitaciones de los sistemas operativos, esta opción no muestra tanta información adicional en Windows 98 y Windows Millennium. |
/help, /? |
Muestra la sintaxis de comandos y las opciones de la versión actual. |
Comentarios
Para ejecutar Ngen.exe, es necesario disponer de privilegios administrativos.
Ngen.exe genera imágenes nativas para el ensamblado especificado y todas sus dependencias. Las dependencias se determinan a partir de las referencias del manifiesto del ensamblado. El único escenario en el que es necesario instalar por separado una dependencia tiene lugar cuando la aplicación carga dicha dependencia utilizando la reflexión, por ejemplo, llamando al método Assembly.Load.
.gif "Nota importante") Nota importante: |
|---|
No utilice el método Assembly.LoadFrom con imágenes nativas. Otros ensamblados no podrán utilizar una imagen cargada con este método en el contexto de ejecución. |
Ngen.exe mantiene un recuento de las dependencias. Por ejemplo, suponga que MyAssembly.exe y YourAssembly.exe están instalados en la caché de imágenes nativas y que ambos tienen referencias a OurDependency.dll. Si se desinstala MyAssembly.exe, no se desinstala OurDependency.dll. Sólo se quita cuando también se desinstala YourAssembly.exe.
Si está generando una imagen nativa para un ensamblado en la caché de ensamblados global, especifique su nombre para mostrar. Vea Assembly.FullName.
Las imágenes nativas generadas por Ngen.exe se pueden compartir en los dominios de aplicación. Esto significa que Ngen.exe puede utilizarse en escenarios de aplicaciones que requieren el uso compartido de los ensamblados entre los dominios de aplicación. Para especificar una neutralidad de dominios:
Aplique el atributo LoaderOptimizationAttribute a la aplicación.
Establezca la propiedad AppDomainSetup.LoaderOptimization al crear la información de instalación de un nuevo dominio de aplicación.
Utilice siempre código neutral respecto del 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 podrá utilizar.
Nota
No se puede descargar código neutral con respecto del dominio y el rendimiento puede resultar algo más lento, especialmente al obtener acceso a miembros estáticos.
Generar imágenes para distintos escenarios
Una vez generada la imagen nativa de un ensamblado, el motor en tiempo de ejecución intenta localizar y utilizar automáticamente la imagen nativa cada vez que se ejecuta el ensamblado. Se pueden generar varias imágenes, en función de los escenarios de uso.
Por ejemplo, si se ejecuta un ensamblado en un escenario de análisis o de depuración, el motor en tiempo de ejecución buscará la imagen nativa generada con las opciones /Debug o /Profile. Si no puede encontrar una imagen nativa coincidente, el motor en tiempo de ejecución volverá a la compilación JIT estándar. La única forma de depurar imágenes nativas es crear una imagen nativa con la opción /Debug.
La acción uninstall también reconoce los escenarios, por lo que se pueden desinstalar todos los escenarios o sólo los escenarios seleccionados.
Determinar cuándo utilizar imágenes nativas
Las imágenes nativas pueden ofrecer mejoras de rendimiento en dos áreas: uso de memoria mejorado y tiempo de inicio reducido.
Nota
El rendimiento de las imágenes nativas depende de una serie de factores que dificultan el análisis, como los modelos de acceso a código y a datos, el número de llamadas realizadas a través de los límites de los módulos y el número de dependencias que ya han sido cargadas por otras aplicaciones. La única forma de determinar si las imágenes nativas benefician a la aplicación es mediante la realización de evaluaciones de rendimiento cuidadosas en los escenarios de implementación clave.
Uso de memoria mejorado
Las imágenes nativas pueden mejorar significativamente el uso de memoria cuando el código se comparte entre los procesos. Las imágenes nativas son archivos PE de Windows, de modo que una única copia de un archivo .dll pueden compartirla varios procesos; en cambio, el código nativo generado por el compilador JIT se almacena en la memoria privada y no se puede compartir.
Las aplicaciones que se ejecutan con los Servicios de Terminal Server también pueden beneficiarse de las páginas de código compartido.
Además, al no cargar el compilador JIT, se guarda una cantidad de memoria fija para cada instancia de la aplicación.
Inicio de aplicación más rápido
Precompilar los ensamblados con Ngen.exe puede reducir el tiempo de inicio de algunas aplicaciones. En general, pueden obtenerse mejoras cuando las aplicaciones comparten ensamblados de componentes porque, una vez iniciada la primera aplicación, los componentes compartidos ya estarán cargados para las siguientes aplicaciones. Un 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 predomina el tiempo de acceso al disco duro.
El enlace fuerte puede afectar al tiempo de inicio ya que todas las imágenes con enlaces fuertes al ensamblado de aplicación principal deben cargarse al mismo tiempo.
Nota
Si dispone de componentes compartidos con nombre seguro, colóquelos en la caché de ensamblados global. El compilador efectúa una validación adicional de los ensamblados con nombre seguro que no se encuentran en la caché de ensamblados global, lo que anula cualquier mejora del tiempo de inicio obtenida gracias al uso de imágenes nativas.
Importancia de las direcciones base de ensamblados
Como las imágenes nativas son archivos PE de Windows, están sujetas a las mismas cuestiones de cambio de ubicación que otros archivos ejecutables. El costo de rendimiento de las reubicaciones es aún más pronunciado si se utilizan enlaces fuertes.
Para establecer la dirección base de una imagen nativa, utilice la opción adecuada del compilador para establecer la dirección base del ensamblado. Ngen.exe utiliza esta dirección base para la imagen nativa.
Nota
Las imágenes nativas son de mayor tamaño que los ensamblados administrados a partir de los que se crearon. Deberán calcularse las direcciones base para poder permitir estos tamaños mayores.
Puede utilizar una herramienta, como dumpbin.exe, para ver la dirección base preferida de una imagen nativa.
Resumen de las consideraciones de uso
Las siguientes consideraciones generales y consideraciones sobre la aplicación pueden ayudarle a decidir si merece la pena asumir el esfuerzo de evaluar las imágenes nativas de la aplicación:
Las imágenes nativas se cargan más rápido que MSIL, ya que eliminan la necesidad de ejecutar muchas actividades en el inicio, como la compilación JIT y la comprobación de la seguridad de tipos.
Las imágenes nativas requieren un espacio de trabajo inicial más pequeño, ya que el compilador JIT no es necesario.
Las imágenes nativas permiten un uso compartido del código entre los procesos.
Las imágenes nativas requieren más espacio en el disco duro que los ensamblados de MSIL y pueden tardar bastante tiempo en generarse.
Es necesario mantener las imágenes nativas.
Es necesario volver a generar las imágenes cuando se realiza el mantenimiento del ensamblado original o de una de sus dependencias.
Un solo ensamblado puede necesitar varias imágenes nativas para su uso en aplicaciones o escenarios diferentes. Por ejemplo, la información de configuración de dos aplicaciones podría producir distintas decisiones de enlace para el mismo ensamblado dependiente.
La generación de imágenes nativas sólo puede ser llevada a cabo por un administrador; es decir, deberá realizarse desde una cuenta de Windows del grupo de administradores.
Además de estas consideraciones generales, hay que tener en cuenta la naturaleza de la aplicación a la hora de determinar si las imágenes nativas podrían proporcionar una mejora del rendimiento:
Si la aplicación se ejecuta en un entorno que utiliza muchos componentes compartidos, las imágenes nativas permiten un uso compartido de los componentes por parte de varios procesos.
Si la aplicación utiliza varios dominios de aplicación, las imágenes nativas permiten un uso compartido de las páginas de códigos entre los distintos dominios.
Nota
En las versiones 1.0 y 1.1 de .NET Framework, los dominios de aplicación no pueden compartir las imágenes nativas. Éste no es el caso en la versión 2.0.
Si la aplicación va a ejecutarse en Terminal Server, las imágenes nativas permiten un uso compartido de las páginas de códigos.
En general, las aplicaciones de gran tamaño se benefician de la compilación de imágenes nativas. En cambio, las aplicaciones de pequeño tamaño no suelen beneficiarse.
Para las aplicaciones de ejecución prolongada, la compilación JIT en tiempo de ejecución ofrece un rendimiento ligeramente superior al de las imágenes nativas. (El enlace fuerte puede mitigar hasta cierto punto esta diferencia de rendimiento.)
Enlace fuerte
El enlace fuerte aumenta el rendimiento y reduce el tamaño del espacio de trabajo de las imágenes nativas. El inconveniente del enlace fuerte es que todas las imágenes con enlaces fuertes a un ensamblado deben cargarse al cargar el ensamblado. Esto puede aumentar significativamente el tiempo de inicio de una aplicación de gran tamaño.
El enlace fuerte es adecuado para las dependencias que se cargan en todos los escenarios de la aplicación en los que el rendimiento es un factor crítico. Al igual que con cualquier otro aspecto del uso de imágenes nativas, la realización de evaluaciones de rendimiento cuidadosas constituye la única forma de determinar si el enlace fuerte mejora el rendimiento de la aplicación.
Los atributos DependencyAttribute y DefaultDependencyAttribute permiten suministrar sugerencias de enlace fuerte a Ngen.exe.
Nota
Estos atributos son sugerencias a Ngen.exe, no comandos. El uso de estos atributos no garantiza el enlace fuerte. El significado de estos atributos puede cambiar en futuras versiones.
Especificar una sugerencia de enlace para una dependencia
Aplique DependencyAttribute a un ensamblado para indicar la probabilidad de que se cargue una dependencia especificada. LoadHint.Always indica que el enlace fuerte es adecuado, Default indica que debe utilizarse el valor predeterminado de la dependencia y Sometimes indica que el enlace fuerte no es adecuado.
En el siguiente código se muestran los atributos de un ensamblado que tiene dos dependencias. La primera dependencia (Assembly1) es una candidata adecuada para el enlace fuerte, pero la segunda (Assembly2) no lo es.
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 de ensamblado no incluye la extensión de nombre de archivo. Pueden utilizarse nombres para mostrar.
Especificar una sugerencia de enlace predeterminado para un ensamblado
Las sugerencias de enlace predeterminado sólo son necesarias para los ensamblados que cualquier aplicación con una dependencia sobre los mismos vaya a utilizar inmediatamente y con frecuencia. Aplique el atributo DefaultDependencyAttribute con LoadHint.Always a dichos ensamblados para especificar que debería utilizarse un enlace fuerte.
Nota
No hay ningún motivo para aplicar el atributo DefaultDependencyAttribute a los ensamblados .dll que no pertenezcan a esta categoría, porque el hecho de aplicar el atributo con cualquier valor distinto de LoadHint.Always produce el mismo efecto que no aplicar el atributo.
Microsoft utiliza el atributo DefaultDependencyAttribute para especificar que el enlace fuerte es el valor predeterminado para un pequeño número de ensamblados de .NET Framework, como mscorlib.dll.
Solución de problemas
Para confirmar que la aplicación está utilizando imágenes nativas, puede utilizar Visor de registro de enlaces de ensamblados (Fuslogvw.exe). Seleccione Imágenes nativas en el cuadro Registrar categorías de la ventana del visor de registro de enlaces. Fuslogvw.exe proporciona información sobre el motivo por el que se ha rechazado una imagen nativa.
Puede utilizar el ayudante para la depuración administrada (MDA) MDA de jitCompilationStart para determinar el momento en el que el compilador JIT empieza a compilar una función.
Procesamiento diferido
La generación de imágenes nativas para una aplicación de gran tamaño puede llevar bastante tiempo. Del mismo modo, los cambios realizados en un componente compartido o en la configuración del equipo pueden exigir la actualización de muchas imágenes nativas. Las acciones install y update disponen de una opción /queue que coloca en la cola la operación para su ejecución diferida por parte del servicio de imágenes nativas. Además, Ngen.exe dispone de las acciones queue y executeQueuedItems, que proporcionan algo de control sobre el servicio. Para obtener más información, vea Servicio de imágenes nativas.
Imágenes nativas y compilación JIT
Si Ngen.exe encuentra algún método en un ensamblado que no puede generar, excluye el método de la imagen nativa. Una vez que el motor de ejecución ejecuta este ensamblado, vuelve a la compilación JIT para los métodos que no se han incluido en la imagen nativa.
Además, no se utilizarán imágenes nativas en caso de que se haya actualizado el ensamblado, o en caso de que la imagen se haya invalidado por cualquier motivo.
Imágenes no válidas
Cuando se utiliza Ngen.exe para crear una imagen nativa de un ensamblado, los resultados dependen de las opciones especificadas en la línea de comandos y de determinadas opciones de configuración del equipo. Entre estas opciones de configuración, se incluyen las siguientes:
Versión de .NET Framework
Versión del sistema operativo, si el cambio es de Windows 9x a Windows NT.
Identidad exacta del ensamblado (identidad de nueva compilación de cambios)
Identidad exacta de todos los ensamblados a los que hace referencia el ensamblado (identidad de nueva compilación de cambios).
Factores de seguridad.
Ngen.exe guarda esta información cuando genera una imagen nativa. Al ejecutar un ensamblado, el motor en tiempo de ejecución busca la imagen nativa generada con las opciones y los valores de configuración que coinciden con el entorno actual del equipo. El motor en tiempo de ejecución vuelve a la compilación JIT del ensamblado si no encuentra una imagen nativa coincidente. Si se realizan los siguientes cambios en la configuración y el entorno de un equipo, las imágenes nativas dejarán de ser válidas:
Versión de .NET Framework
Si se aplica una actualización a .NET Framework, todas las imágenes nativas que se hayan creado mediante Ngen.exe dejarán de ser válidas. Por esta razón, todas las actualizaciones de .NET Framework ejecutan el comando Ngen Update para garantizar que se vuelven a generar todas las imágenes nativas. .NET Framework crea nuevas imágenes nativas de forma automática para las bibliotecas de .NET Framework que instala.
Versión del sistema operativo, si el cambio es de Windows 9x a Windows NT.
Si se cambia la versión del sistema operativo que se está ejecutando en un equipo (por ejemplo, de Windows 98 a Windows XP), todas las imágenes nativas almacenadas en la caché de imágenes nativas dejan de ser válidas. Sin embargo, si el sistema operativo cambia de Windows 2000 a Windows XP, las imágenes no dejan de ser válidas.
Identidad exacta del ensamblado.
Si vuelve a compilar un ensamblado, la imagen nativa correspondiente al ensamblado deja de ser válida.
Identidad exacta de todos los ensamblados a los que hace referencia el ensamblado.
Si se actualiza un ensamblado administrado, todas las imágenes nativas que, directa o indirectamente, dependen de ese ensamblado dejan de ser válidas y deben volver a generarse. Esto se aplica tanto a las referencias ordinarias como a las dependencias con enlaces fuertes. Cuando se aplica una actualización de software, el programa de instalación debe ejecutar un comando Ngen Update para garantizar que se vuelven a generar todas las imágenes nativas dependientes.
Factores de seguridad.
Al modificar la directiva de seguridad del equipo para restringir los permisos previamente concedidos a un ensamblado puede ocurrir que la imagen nativa compilada con anterioridad para dicho ensamblado deje de ser válida.
Para obtener información detallada sobre la forma en que Common Language Runtime administra la seguridad de acceso del código y sobre la forma de utilizar los permisos, vea Seguridad de acceso a código
Ejemplos
El siguiente comando genera una imagen nativa para ClientApp.exe, que se encuentra 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 utilizará dicho archivo. Además, se generarán imágenes nativas para cualquier archivo .dll al que haga referencia ClientApp.exe.
ngen install ClientApp.exe
Una imagen instalada con Ngen.exe también recibe el nombre de 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
A la hora de buscar los ensamblados y sus dependencias, Ngen.exe utiliza la misma lógica de búsqueda que Common Language Runtime. De forma predeterminada, el directorio que contiene ClientApp.exe se utiliza como directorio base de la aplicación y todas las búsquedas de ensamblados comienzan en este directorio. Se puede reemplazar este comportamiento utilizando la opción /AppBase.
Nota
Se trata de un cambio de comportamiento de Ngen.exe en las versiones 1.0 y 1.1 de .NET Framework, donde la base de la aplicación está establecida en el directorio actual.
Un ensamblado puede disponer de una dependencia sin referencia alguna; por ejemplo, si carga un archivo .dll mediante el método Assembly.Load. Se puede crear una imagen nativa de este archivo .dll utilizando la información de configuración del ensamblado de aplicación, con la opción /ExeConfig. El siguiente comando genera una imagen nativa de MyLib.dll, utilizando 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, utilice las mismas opciones de línea de comandos que se utilizaron para su instalación. El siguiente comando desinstala el archivo MyLib.dll del ejemplo anterior.
ngen uninstall c:\myfiles\MyLib.dll /ExeConfig:c:\myapps\MyApp.exe
Para crear una imagen nativa de un ensamblado en la caché de ensamblados global, utilice el nombre para mostrar del ensamblado. Por ejemplo:
ngen install "ClientApp, Version=1.0.0.0, Culture=neutral,
PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL"
NGen.exe generará un conjunto independiente de imágenes para cada escenario que se instale. Por ejemplo, el siguiente comando instala un conjunto completo de imágenes nativas para el funcionamiento normal, otro conjunto completo para la depuración y un tercero para la creación de perfiles:
ngen install MyApp.exe
ngen install MyApp.exe /debug
ngen install MyApp.exe /profile
Mostrar la caché de imágenes nativas
Una vez instaladas las imágenes nativas en la caché, se podrán mostrar mediante Ngen.exe. El siguiente comando muestra todas las imágenes nativas en la caché de imágenes nativas.
ngen display
La acción display muestra primero todos los ensamblados raíz, seguidos de una lista de todas las imágenes nativas del equipo.
Utilice el nombre sencillo de un ensamblado para que se muestre únicamente información de dicho ensamblado. El siguiente comando muestra todas las imágenes nativas de la caché de imágenes nativas que coinciden con el nombre parcial MyAssembly, sus dependencias y todas las raíces que tienen una dependencia en MyAssembly:
ngen display MyAssembly
Conocer las raíces que dependen de un ensamblado de componentes compartidos resulta de gran utilidad para valorar el impacto de una acción update una vez actualizado el componente compartido.
Si se especifica la extensión de archivo de un ensamblado, debe especificarse la ruta de acceso o debe ejecutarse 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"
Actualizar imágenes
Las imágenes suelen actualizarse después de que se haya actualizado un componente compartido. Para actualizar todas las imágenes nativas que hayan cambiado o cuyas dependencias hayan cambiado, utilice la acción update sin ningún argumento.
ngen update
Actualizar 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 utilizando la opción /queue. Para obtener más información sobre la opción /queue y las prioridades de instalación, vea Servicio de imágenes nativas.
ngen update /queue
Desinstalar imágenes
Ngen.exe mantiene una lista de dependencias, para que los componentes compartidos se quiten únicamente cuando se hayan quitado todos los ensamblados que dependen de ellos. Además, si un componente compartido se ha instalado como raíz, no se quitará.
El siguiente comando desinstala todos los escenarios de la raíz ClientApp.exe:
ngen uninstall ClientApp
Se puede utilizar la acción uninstall para quitar escenarios concretos. El siguiente comando desinstala todos los escenarios de depuración de ClientApp.exe:
ngen uninstall ClientApp /debug
Nota
La desinstalación de escenarios /debug no desinstala los escenarios que incluyen tanto /profile como /debug.
El siguiente comando desinstala todos los escenarios de una versión concreta de ClientApp.exe:
ngen uninstall "ClientApp, Version=1.0.0.0"
Los siguientes comandos desinstalan todos los escenarios de "ClientApp, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL", o simplemente el escenario de depuración de dicho 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 ocurre con la acción install, cuando se suministra una extensión, es necesario 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, vea Servicio de imágenes nativas.
Vea también
Conceptos
Cómo el motor en tiempo de ejecución ubica ensamblados