Nativo imagem gerador (NGen.exe)
O Native Image Generator (Ngen.exe) é uma ferramenta que melhora o desempenho de aplicativos gerenciados. NGen.exe cria nativo imagens, que são arquivos contendo compilado código de máquina de processador específico e instala-los para o nativo imagem cache no computador local. O Runtime pode usar imagens nativas do cache em vez disso, usando o compilador Just-In-Time (JIT) para compilar o assembly original.
NGen.exe foi alterado significativamente no .NET estrutura versão 2.0:
A instalação de um assembly também inclui suas dependências, simplificando a sintaxe do NGen.exe.
nativo imagens agora podem ser compartilhadas entre domínios de aplicativo.
Uma nova ação, update, recria imagens que tenham sido invalidadas.
Ações podem ser adiadas para execução por um serviço que usa o time ocioso do computador para gerar e instalar imagens.
Uma causa de invalidação de imagem foram eliminada.
Para obter informações adicionais sobre o uso NGen.exe e o nativo serviço de imagem, consulte Serviço de imagem nativa.
.gif "Observação") Observação: |
|---|
Sintaxe do NGen.exe das versões 1.0 e 1.1 do .NET estrutura pode ser encontrada no Nativo imagem gerador (NGen.exe) herdado sintaxe. |
ngen <action> [options]
ngen /? | /help
Ações
A tabela a seguir mostra a sintaxe de cada ação. Para obter descrições das partes individuais de actionArguments, consulte o Argumentos, Cenários, and Config tabelas. The Opções tabela descreve o options e as opções de Ajuda.
Ação |
Descrição |
|---|---|
install [assemblyName | assemblyPath] [scenarios] [config] [/queue[:{1|2|3}]] |
Gerar nativo imagens para um assembly e suas dependências e instalar as imagens no nativo cache de imagem. If /queue for especificado, a ação é colocada em na fila para o nativo serviço de imagem. A prioridade padrão é 3. |
uninstall [assemblyName | assemblyPath | *] [scenarios] [config] |
Excluir o nativo imagens de um assembly e suas dependências do nativo cache de imagem. Para desinstalar uma única imagem e suas dependências, use os mesmos argumentos da linha de comando que foram usados para instalar a imagem. |
update [/queue] |
Atualização nativo imagens que se tornem inválidas. If /queue for especificado, as atualizações estão na na fila para o nativo serviço de imagem. As atualizações sempre são agendadas com prioridade 3, portanto, são executadas quando o computador estiver ocioso. |
display [assemblyName | assemblyPath] |
Exibir o estado do nativo imagens para um assembly e suas dependências. Se nenhum argumento for fornecido, todos os itens a nativo cache de imagem é exibida. |
executeQueuedItems [1|2|3] |
executar os trabalhos na fila de compilação. Se for especificada uma prioridade, compilação trabalhos com prioridade maior ou igual são executados. Se nenhuma prioridade for especificada, todos os trabalhos na fila de compilação são executados. |
queue {pause | continue | status} |
pausar o nativo serviço de imagem, permitir que o serviço em pausar continuar ou consultar o status do serviço. |
Argumentos
Argumento |
Descrição |
|---|---|
assemblyName |
O nome para exibição completo do assembly. Por exemplo, "myAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0038abc9deabfle5". Observação:
Você pode fornecer um nome de assembly parcial, sistema autônomo myAssembly, para o display e uninstall ações.
Somente um assembly pode ser especificado por linha de comando do NGen.exe. |
assemblyPath |
O caminho explícito do assembly. Você pode especificar um caminho completo ou relativo. Se você especificar um nome de arquivo sem um caminho, o assembly deve estar localizado no diretório corrente. Somente um assembly pode ser especificado por linha de comando do NGen.exe. |
Cenários
Cenário |
Descrição |
|---|---|
/Debug |
Gerar nativo imagens que podem ser usadas em um depurador. |
/Profile |
Gerar nativo imagens que podem ser usadas em um criador de perfil. |
/NoDependencies |
O número mínimo de gerar nativo imagens requeridas pelas opções cenário especificado. |
Config
Configuração |
Descrição |
|---|---|
/ExeConfig:exePath |
Use a configuração do assembly executável especificado. NGen.exe precisa tomar decisões mesmas sistema autônomo o carregador ao ligar a dependências. Quando um componente compartilhado é carregado em time de execução, usando o Load o método, o arquivo de configuração do aplicativo determina as dependências que são carregadas para o componente compartilhado — por exemplo, a versão de uma dependência é carregada. The /ExeConfig comutador fornece orientação NGen.exe em que dependências devem ser carregadas no time de execução. |
/AppBase:directoryPath |
Quando localizar dependências, use o diretório especificado sistema autônomo a base de aplicativo. |
Opções
Opção |
Descrição |
|---|---|
/nologo |
Suprimir a exibição de faixa de inicialização do Microsoft. |
/silent |
Suprimir a exibição das mensagens de êxito. |
/verbose |
Exibir informações detalhadas para depuração. Observação:
Devido às limitações do sistema operacional, essa opção não for exibido sistema autônomo informações adicionais muito no Windows 98 e Windows Millennium edição .
|
/help, /? |
Exibir sintaxe do comando e opções para a versão corrente. |
Comentários
Para executar NGen.exe, você deve ter privilégios administrativos.
NGen.exe gera nativo imagens para o assembly especificado e todas as suas dependências. Dependências são determinadas de referências no manifesto do assembly. A única situação em que você precisa instalar uma dependência separadamente é quando o aplicativo carrega-lo usando reflexão, por exemplo, chamando o Assembly.Load método.
.gif "Observação importante") Observação importante: |
|---|
Não use o Assembly.LoadFrom método com imagens nativas. Uma imagem carregada com esse método não pode ser usada por outros assemblies no contexto de execução. |
NGen.exe mantém uma contagem de dependências. Por exemplo, suponha que MyAssembly.exe e YourAssembly.exe são instalados no nativo cache de imagem e ambas têm referências a OurDependency.dll. If MyAssembly.exe é desinstalado OurDependency.dll não é desinstalado. Só é removido quando YourAssembly.exe também é desinstalado.
Se você estiver gerando uma imagem nativa para um assembly no cache de assembly global, especificar seu nome para exibição. Consulte Assembly.FullName.
O nativo imagens gera NGen.exe podem ser compartilhadas entre domínios de aplicativo. Isso significa que você pode usar NGen.exe em cenários de aplicativos que exigem conjuntos de módulos podem ser compartilhados entre domínios de aplicativo. Para especificar neutralidade do domínio:
Aplicar o LoaderOptimizationAttribute o atributo para seu aplicativo.
conjunto o AppDomainSetup.LoaderOptimization propriedade ao criar informações de configuração para um novo domínio do aplicativo.
Sempre use o código de domínio neutro ao carregar o mesmo assembly em vários domínios do aplicativo. Se um nativo imagem é carregada em um domínio do aplicativo compartilhada após ter sido carregado em um domínio compartilhado, não pode ser usado.
| Observação: |
|---|
Código de domínio neutro não pode ser descarregado e desempenho pode ser um pouco mais lento, especialmente ao acessar membros estático. |
Gerando imagens para diferentes situações
Após ter gerado um nativo imagem para um assembly, o tempo de execução automaticamente tenta localizar e usar isso nativo sempre que for executada o assembly de imagem. Várias imagens podem ser geradas, dependendo dos cenários de uso.
Por exemplo, se você executar um assembly em uma depuração ou cenário de criação de perfil, o tempo de execução procura por um nativo imagem que foi gerada com o /Debug ou /Profile opções. Se não conseguir encontrar uma correspondência nativo imagem, o tempo de execução será revertido para compilação JIT padrão. A única maneira de depurar nativo imagens é criar um nativo imagem com o /Debug opção.
The uninstall ação também reconhece cenários, portanto, você pode desinstalar todos os cenários ou apenas cenários selecionados.
Determinar quando usar nativo imagens
nativo imagens podem fornecer melhorias de desempenho em duas áreas: uso de memória aprimorada e time de inicialização menor.
| Observação: |
|---|
Desempenho de nativo imagens depende de vários fatores que tornam difícil, sistema autônomo padrões de acesso a código e dados, quantas chamadas são feitas através de limites de módulo e quantos dependências já foram carregadas pelo análise outros aplicativos. A única maneira de determinar se nativo imagens benefício seu aplicativo por medidas de desempenho cuidado nos seus cenários de implantação principais. |
Uso de memória aprimorada
nativo imagens podem melhorar significativamente o uso de memória quando código é compartilhado entre processos. Imagens nativas são arquivos do Windows PE, portanto, uma única cópia de um arquivo .dll possa ser compartilhada por vários processos; por outro lado, nativo código produzido pelo compilador JIT é armazenado na memória particular e não pode ser compartilhado.
Aplicativos executados em serviços de terminal também podem se beneficiar do páginas de código compartilhado.
Além disso, carregar o compilador JIT não salva uma quantidade fixa de memória para cada instância do aplicativo.
Mais rápida inicialização de aplicativo
Pré-compilar assemblies com NGen.exe pode melhorar o time de inicialização de alguns aplicativos. Em geral, os ganhos podem ser feitos quando aplicativos compartilham os conjuntos de componentes como após o primeiro aplicativo ter sido iniciado os componentes compartilhados são já carregados para aplicativos subseqüentes. Inicialização a frio, em que todos sistema autônomo assemblies em um aplicativo devem ser carregados do disco rígido, não se beneficiar o máximo de nativo imagens porque o time de acesso ao disco rígido predominates.
Ligação de disco rígida pode afetar o time de inicialização, como todas as imagens que são difíceis de vinculados a aplicativo assembly principal deve ser carregada ao mesmo time.
| Observação: |
|---|
Se você tiver compartilhado componentes que são fortes, colocá-los no cache de assembly global. O carregador realiza validação extra em assemblies fortes que não estão no cache global de assemblies, eliminar efetivamente alguma melhoria no time de inicialização obtidas usando nativo imagens. |
Importância dos endereços de base do assembly
Porque nativo imagens são arquivos do Windows PE, eles estão sujeitos aos mesmos problemas de rebasing sistema autônomo outros arquivos executável. O custo de desempenho de realocação é ainda mais pronunciado se ligação de disco rígida for empregada.
Para conjunto o endereço básico para um nativo de imagem, use a opção apropriada do seu compilador para conjunto o endereço básico para o assembly. NGen.exe usa esse endereço básico para o nativo imagem.
| Observação: |
|---|
nativo imagens são maiores que os módulos gerenciado do qual foram criados. Endereços base devem ser calculados para permitir esses tamanhos maiores. |
Você pode usar uma ferramenta sistema autônomo dumpbin.exe para exibir o endereço básico preferido de um nativo imagem.
Resumo das considerações de uso
As seguintes considerações Geral e considerações sobre aplicativos pode ajudá decidir se deve realizar o esforço de avaliar nativo imagens para o seu aplicativo:
Imagens nativas carregam mais rápido do que o MSIL porque eles eliminam a necessidade de muitas atividades de inicialização, sistema autônomo verificação de compilação e a segurança de tipos JIT.
nativo imagens exigem um conjunto de trabalho menor inicial porque não é necessário para o compilador JIT.
nativo imagens permitem código compartilhamento entre processos.
nativo imagens exigem mais espaço em disco rígido que os assemblies MSIL e pode exigir um time considerável para gerar.
nativo imagens devem ser mantidas.
Imagens precisará ser regenerado quando o assembly original ou uma de suas dependências é atendida.
Um único assembly pode ser necessário múltiplo nativo imagens para uso em aplicativos diferentes ou cenários diferentes. Por exemplo, as informações de configuração de dois aplicativos podem resultar em decisões de ligação diferente para o mesmo assembly dependente.
nativo imagens devem ser geradas por um administrador; isto é, de uma conta do Windows em administradores de agrupar.
Com essas considerações Geral, a natureza do seu aplicativo deve ser considerada ao determinar se nativo imagens podem fornecer um benefício de desempenho:
Se o seu aplicativo for executado em um ambiente que usa muitos componentes compartilhados, nativo imagens permitem que os componentes que serão compartilhadas por vários processos.
Se o seu aplicativo utiliza vários domínios de aplicativo, nativo imagens permitir que as páginas de código a ser compartilhada entre domínios.
Observação:Nas versões do .NET estrutura 1.0 e 1.1, nativo imagens não podem ser compartilhadas entre domínios de aplicativo. Isso não for o caso na versão 2.0.
Se seu aplicativo for executado em servidor de terminal, nativo imagens permitem compartilhamento de páginas de código.
Geralmente, os aplicativos grandes beneficiar compilação para nativo imagens. Pequenos aplicativos geralmente não se o beneficiam.
Para aplicativos de execução demorada, compilação JIT de time de execução executa um pouco melhor do que nativo imagens. (Ligação de disco rígida pode atenuar essa diferença de desempenho em algum grau.)
Vinculação de disco rígido
Ligação de disco rígida aumenta a taxa de transferência e reduz o dimensionar do conjunto de trabalho para nativo imagens. A desvantagem da ligação de disco rígida é que todas as imagens que estão no disco rígidas acopladas a um assembly devem ser carregadas quando o assembly foi carregado. Isso pode aumentar significativamente o time de inicialização de um aplicativo grande.
Ligação de disco rígida é apropriada para as dependências que são carregadas em cenários de desempenho crítico tudo do seu aplicativo. sistema autônomo ocorre com qualquer aspecto do nativo uso, cuidado medidas de desempenho são a única forma de determinar se ligação de disco rígida melhora o desempenho do aplicativo de imagem.
The DependencyAttribute e DefaultDependencyAttribute atributos permitem que você forneça dicas de ligação de disco rígido para NGen.exe.
| Observação: |
|---|
Esses atributos são as dicas de NGen.exe, não os comandos. Usá-los não garante a ligação de disco rígida. O significado desses atributos pode mudar em futuras versões. |
Especificando uma dica de ligação para uma dependência
Aplicar o DependencyAttribute para um assembly para indicar a probabilidade de uma dependência especificada será carregada. LoadHint.Always indica que a vinculação de disco rígida é apropriada, Default indica que o padrão para a dependência deve ser usado, e Sometimes indica que ligação de disco rígida não é apropriada.
O código a seguir mostra os atributos para um assembly que possui dois dependências. A primeira dependência (Assembly1) é um candidato apropriado para vinculação de disco rígido e o segundo (Assembly2) não é.
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)];
O nome do assembly não inclui a extensão de nome de arquivo. Nomes de exibição podem ser usados.
Especificando um padrão Binding dica para um assembly
As dicas de ligação padrão só são necessários para assemblies que serão usados com freqüência e imediatamente por qualquer aplicativo que tem uma dependência. Aplicar o DefaultDependencyAttribute com LoadHint.Always para esses módulos (assemblies) para especificar essa ligação disco rígida deve ser usada.
| Observação: |
|---|
Não há nenhum motivo para aplicar DefaultDependencyAttribute para sistema autônomo assemblies de DLL não estão nessa categoria, sistema autônomo aplicar o atributo com qualquer valor diferente de LoadHint.Always tem o mesmo efeito que não aplicar o atributo todo. |
A Microsoft usa o DefaultDependencyAttribute Para especificar que a vinculação de disco rígida é padrão para um número muito pequeno de assemblies do .NET estrutura, sistema autônomo mscorlib.dll.
Solução de problemas
Para confirmar que nativo imagens estão sendo usadas por seu aplicativo, você pode usar o Assembly Binding Log Viewer (Fuslogvw.exe). selecionar nativo Imagens in the Categorias de log caixa na janela de visualizador de log de ligação. Fuslogvw.exe fornece informações sobre por que um nativo imagem foi rejeitada.
Você pode usar o jitCompilationStart MDA Assistente de depuração gerenciada (MDA) para determinar quando o compilador JIT é iniciado compilar uma função.
Processamento adiado
Geração de nativo imagens para um aplicativo muito grande pode levar um time considerável. Da mesma forma, as alterações em um componente compartilhado ou alterações nas configurações do computador podem exigir muitos nativo imagens a ser atualizado. The install e update ações têm um /queue opção filas a operação para adiada execução com o nativo serviço de imagem. Além disso, NGen.exe tem queue e executeQueuedItems ações que oferecem algum controle sobre o serviço. Para obter mais informações, consulte Serviço de imagem nativa.
Imagens nativas e compilação JIT
Se NGen.exe encontrar todos os métodos em um assembly que não é possível gerar, ele exclui-los da nativo imagem. Quando o tempo de execução executa este assembly, será revertida para compilação JIT para os métodos que não foram incluídos na nativo imagem.
Além disso, nativo imagens não são usadas se o assembly tiver sido atualizado ou se a imagem foi invalidada por qualquer motivo.
inválido Imagens
Quando você usa NGen.exe para criar um nativo imagem de um assembly, a saída depende das opções de linha de comando que você especificar e determinadas configurações no seu computador. Essas configurações incluem o seguinte:
A versão do .NET estrutura.
A versão do sistema operacional, se a alterar da família do Windows 9 x para a família do Windows NT.
A identidade exata do assembly (recompilação altera identidade).
A identidade exata de todos os assemblies o conjunto de referências (recompilação alterações identidade).
Fatores de segurança.
NGen.exe registra essas informações quando ele gera um nativo imagem. Quando você executar um assembly, o tempo de execução procura o nativo imagem gerada com opções e configurações que correspondem ao ambiente corrente do computador. O tempo de execução será revertido para compilação JIT de um assembly se ele não pode localizar uma correspondência nativo imagem. As seguintes alterações às configurações do computador e ambiente causar imagens nativas para se tornar inválido:
A versão do .NET estrutura.
Se você aplicar uma atualização para o .NET estrutura, tornar-se todas as imagens nativas que você tenha criado usando NGen.exe inválido. Por essa razão, todas as atualizações do .NET estrutura executar o Ngen Update comando, para garantir que todos os nativo imagens são geradas novamente. O .NET estrutura cria automaticamente novas nativo imagens para as bibliotecas do .NET estrutura que ele instala.
A versão do sistema operacional, se a alterar da família do Windows 9 x para a família do Windows NT.
Por exemplo, se a versão do sistema operacional em execução em um computador mudar do Windows 98 para Windows XP, todos os nativo imagens armazenadas no nativo imagem cache se tornem inválido. No entanto, se mudar o sistema operacional do Windows 2000 para o Windows XP, as imagens não são invalidadas.
A identidade exata do assembly.
Se você recompilar um assembly, o assembly do correspondente nativo imagem se torna inválido.
A identidade exata de todos os assemblies referências de assembly.
Se você atualizar um assembly gerenciado, todas as imagens nativas direta ou indiretamente dependentes do assembly se tornarão inválido e precisará ser gerado novamente. Isso inclui referências comuns e as dependências de disco rígido limite. Sempre que uma atualização de software é aplicada, o programa de instalação deve ser executado um Ngen Update comando para garantir que todos os dependentes nativo imagens são geradas novamente.
Fatores de segurança.
Alteração de diretiva de segurança de computador para restringir as permissões concedidas anteriormente a um assembly pode causar compilados anteriormente nativo imagem para esse assembly se tornem inválidos.
Para obter informações detalhadas sobre como o Common linguagem tempo de execução administra a segurança de acesso do código e como usar as permissões, consulte Segurança de Acesso de código
Exemplos
O comando a seguir gera um nativo imagem para ClientApp.exe, localizado no diretório corrente e instala a imagem a nativo cache de imagem. Se existir um arquivo de configuração para o assembly, NGen.exe utilizará. Além disso, nativo imagens são geradas para arquivos de qualquer .dll que ClientApp.exe referências.
ngen install ClientApp.exe
Uma imagem instalada com NGen.exe também é chamada de uma raiz. Uma raiz pode ser um aplicativo ou um componente compartilhado.
O comando a seguir gera um nativo imagem para MyAssembly.exe com o caminho especificado.
ngen install c:\myfiles\MyAssembly.exe
Quando a localização de módulos (assemblies) e suas dependências, NGen.exe usa a mesma lógica probing usada pelo common linguagem tempo de execução. Por padrão, o diretório que contém ClientApp.exe é usado sistema autônomo o diretório base de aplicativo, e todos sistema autônomo assembly probing começa nesse diretório. Você pode substituir esse comportamento usando o /AppBase opção.
| Observação: |
|---|
Isso é uma alterar de comportamento NGen.exe no .NET estrutura versões 1.0 e 1.1, onde a base de aplicativo é definida para a pasta corrente. |
Um assembly pode ter uma dependência sem uma referência, por exemplo, se ele carrega um arquivo .dll, usando o Assembly.Load método. Você pode criar um nativo imagem para um arquivo .dll usando informações de configuração para o aplicativo assembly, a /ExeConfig opção. O comando a seguir gera um nativo imagem para MyLib.dll, usando as informações de configuração do MyApp.exe.
ngen install c:\myfiles\MyLib.dll /ExeConfig:c:\myapps\MyApp.exe
Assemblies instalados dessa maneira não são removidos quando o aplicativo for removido.
Para desinstalar uma dependência, use as mesmas opções de linha de comando que foram usadas para instalá-lo. O comando a seguir desinstala o MyLib.dll do exemplo anterior.
ngen uninstall c:\myfiles\MyLib.dll /ExeConfig:c:\myapps\MyApp.exe
Para criar um nativo para um assembly no cache de assemblies global, use o nome para exibição do assembly de imagem. Por exemplo:
ngen install "ClientApp, Version=1.0.0.0, Culture=neutral,
PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL"
NGen.exe gera um conjunto separado de imagens para cada cenário de instalar. Por exemplo, os seguintes comandos instalar um conjunto completo de nativo imagens para a operação normal, outro completo definidas para depuração e um terceiro para a criação de perfil:
ngen install MyApp.exe
ngen install MyApp.exe /debug
ngen install MyApp.exe /profile
Exibindo a imagem nativo cache
Quando imagens nativas estiver instaladas no cache, podem ser exibidas usando NGen.exe. O comando a seguir exibe todos os nativo imagens no nativo cache de imagem.
ngen display
The display ação lista todos os assemblies raiz primeiro, seguido de uma lista de todos os nativo imagens no computador.
Use o nome simples de um assembly para exibir as informações somente para esse assembly. O comando a seguir exibe todos os nativo imagens no nativo cache coincidir com o nome parcial de imagemMyAssembly, suas dependências e todas as raízes que têm uma dependência MyAssembly:
ngen display MyAssembly
Saber quais raízes dependem de um componente compartilhado do assembly é útil para avaliar o impacto de um update ação depois que o componente compartilhado for atualizado.
Se você especificar de extensão de arquivo um assembly, você deve especificar o caminho ou executar NGen.exe de diretório que contém o conjunto:
ngen display c:\myApps\MyAssembly.exe
O comando a seguir exibe todos os nativo imagens no nativo cache com o nome da imagemMyAssembly e a versão 1.0.0.0.
ngen display "myAssembly, version=1.0.0.0"
Atualizando imagens
Imagens geralmente são atualizadas depois que um componente compartilhado foi atualizado. Para atualizar todos os nativo imagens que foram alterados ou cujas dependências foram alteradas, use o update ação sem argumentos.
ngen update
Atualizar todas as imagens pode ser um processo demorado. Você pode enfileirar as atualizações para execução com o o nativo serviço de imagem usando o /queue opção. Para obter mais informações sobre o /queue prioridades de opção e a instalação, consulte Serviço de imagem nativa.
ngen update /queue
Desinstalando imagens
NGen.exe mantém uma lista de dependências, para que os componentes compartilhados são removidos somente quando todos os assemblies que dependem delas foram removidos. Além disso, um componente compartilhado não é removido se tiver sido instalado sistema autônomo uma raiz.
O comando a seguir desinstala todos os cenários para a raiz ClientApp.exe:
ngen uninstall ClientApp
The uninstall ação pode ser usada para remover os cenários específicos. O comando a seguir desinstala todos os cenários de depurar para ClientApp.exe:
ngen uninstall ClientApp /debug
| Observação: |
|---|
Desinstalando /debug cenários não desinstala um cenário que inclui ambos /profile e /debug. |
O comando a seguir desinstala todos os cenários para uma versão específica de ClientApp.exe:
ngen uninstall "ClientApp, Version=1.0.0.0"
Os seguintes comandos desinstalar todos os cenários de "ClientApp, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL", ou apenas o cenário de depurar para esse 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
sistema autônomo ocorre com o install ação, fornecer uma extensão requer executar NGen.exe do diretório contendo o assembly ou especificar um caminho completo.
Para obter exemplos relacionados ao serviço de imagem nativa, consulte Serviço de imagem nativa.
Consulte também
Conceitos
Compilação MSIL para código nativo
Como o Runtime Localiza Assemblies