Ngen.exe (inbyggd avbildningsgenerator)

Den interna avbildningsgeneratorn (Ngen.exe) är ett verktyg som förbättrar prestandan för hanterade program. Ngen.exe skapar inbyggda avbildningar, som är filer som innehåller kompilerad processorspecifik datorkod, och installerar dem i den interna avbildningscacheminnet på den lokala datorn. Körningen kan använda interna avbildningar från cacheminnet i stället för att använda jit-kompilatorn (just-in-time) för att kompilera den ursprungliga sammansättningen.

Ändringar i Ngen.exe i .NET Framework 4:

• Ngen.exe kompilerar nu sammansättningar med fullständigt förtroende och kodåtkomstsäkerhetsprincipen (CAS) utvärderas inte längre.

• Interna avbildningar som genereras med Ngen.exe kan inte längre läsas in i program som körs i partiellt förtroende.

Ändringar i Ngen.exe i .NET Framework version 2.0:

• Om du installerar en sammansättning installeras även dess beroenden, vilket förenklar syntaxen för Ngen.exe.

• Inbyggda avbildningar kan nu delas mellan programdomäner.

• En ny åtgärd, update, återskapar avbildningar som har ogiltigförklarats.

• Åtgärder kan skjutas upp för körning av en tjänst som använder inaktiv tid på datorn för att generera och installera avbildningar.

• Vissa orsaker till bild ogiltighet har eliminerats.

I Windows 8, se Intern avbildningsaktivitet.

Mer information om hur du använder Ngen.exe och den interna avbildningstjänsten finns i Intern bildtjänst.

Det här verktyget installeras automatiskt med Visual Studio. Om du vill köra verktyget använder du Visual Studio Developer Command Prompt eller Visual Studio Developer PowerShell.

Skriv följande vid kommandotolken:

Syntax

ngen action [options]

ngen /? | /help

Åtgärder

I följande tabell visas syntaxen för varje action. Beskrivningar av de enskilda delarna i en actionfinns i tabellerna Argument, Prioritetsnivåer, Scenarier och Konfiguration . Tabellen Alternativ beskriver hjälpväxlarna options och .

Åtgärd	beskrivning
install[assemblyNameassemblyPath | ] [scenarios] [config] [/queue[:{1||23}]]	Generera inbyggda avbildningar för en sammansättning och dess beroenden och installera avbildningarna i den interna avbildningscacheminnet. Om /queue anges placeras åtgärden i kö för den interna avbildningstjänsten. Standardprioriteten är 3. Se tabellen Prioritetsnivåer .
uninstall [assemblyName | assemblyPath] [scenarios] [] [config]	Ta bort de inbyggda avbildningarna av en sammansättning och dess beroenden från den interna avbildningscacheminnet. Om du vill avinstallera en enskild avbildning och dess beroenden använder du samma kommandoradsargument som användes för att installera avbildningen. Obs! Från och med .NET Framework 4 stöds inte längre åtgärden uninstall *.
update [/queue]	Uppdatera inbyggda avbildningar som har blivit ogiltiga. Om /queue anges placeras uppdateringarna i kö för den interna avbildningstjänsten. Uppdateringar schemaläggs alltid med prioritet 3, så de körs när datorn är inaktiv.
display [assemblyName | assemblyPath]	Visa tillståndet för de inbyggda bilderna för en sammansättning och dess beroenden. Om inget argument anges visas allt i den interna bildcachen.
executeQueuedItems [1|2|3] -eller- eqi [1|2|3]	Kör köade kompileringsjobb. Om en prioritet anges körs kompileringsjobb med högre eller lika prioritet. Om ingen prioritet har angetts körs alla köade kompileringsjobb.
queue{pause | | continuestatus}	Pausa den interna avbildningstjänsten, låt den pausade tjänsten fortsätta eller fråga efter tjänstens status.

Argument

Argument	beskrivning
assemblyName	Sammansättningens fullständiga visningsnamn. Exempel: "myAssembly, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0038abc9deabfle5" Obs! Du kan ange ett partiellt sammansättningsnamn, till exempel myAssembly, för display åtgärderna och uninstall . Endast en sammansättning kan anges per Ngen.exe kommandorad.
assemblyPath	Den explicita sökvägen för sammansättningen. Du kan ange en fullständig eller relativ sökväg. Om du anger ett filnamn utan sökväg måste sammansättningen finnas i den aktuella katalogen. Endast en sammansättning kan anges per Ngen.exe kommandorad.

Prioritetsnivåer

Prioritet	beskrivning
1	Interna avbildningar genereras och installeras omedelbart, utan att vänta på inaktiv tid.
2	Interna avbildningar genereras och installeras utan att vänta på inaktiv tid, men efter att alla prioritet 1-åtgärder (och deras beroenden) har slutförts.
3	Interna avbildningar installeras när den interna avbildningstjänsten upptäcker att datorn är inaktiv. Se Intern avbildningstjänst.

Scenarier

Scenario	beskrivning
/Debug	Generera interna avbildningar som kan användas under ett felsökningsprogram.
/Profile	Generera interna avbildningar som kan användas under en profilerare.
/NoDependencies	Generera det minsta antalet interna avbildningar som krävs av de angivna scenarioalternativen.

Konfigurera

Konfiguration	beskrivning
/ExeConfig: exePath	Använd konfigurationen av den angivna körbara sammansättningen. Ngen.exe måste fatta samma beslut som inläsaren vid bindning till beroenden. När en delad komponent läses in vid körning, med hjälp Load av metoden, avgör programmets konfigurationsfil de beroenden som läses in för den delade komponenten, till exempel vilken version av ett beroende som läses in. Växeln /ExeConfig ger Ngen.exe vägledning om vilka beroenden som ska läsas in vid körning.
/AppBase: directoryPath	När du lokaliserar beroenden använder du den angivna katalogen som programbas.

Alternativ

Alternativ	Description
/nologo	Ignorera microsoft-startbanderollen.
/silent	Ignorera visning av lyckade meddelanden.
/verbose	Visa detaljerad information för felsökning.
/help, /?	Visa kommandosyntax och alternativ för den aktuella versionen.

Kommentarer

Om du vill köra Ngen.exe måste du ha administratörsbehörighet.

Från och med .NET Framework 4 kan de inbyggda avbildningar som genereras med Ngen.exe inte längre läsas in i program som körs i delvis förtroende. I stället anropas jit-kompilatorn (just-in-time).

Ngen.exe genererar interna avbildningar för den sammansättning som anges av assemblyname argumentet till install åtgärden och alla dess beroenden. Beroenden bestäms från referenser i sammansättningsmanifestet. Det enda scenario där du behöver installera ett beroende separat är när programmet läser in det med reflektion, till exempel genom att anropa Assembly.Load metoden.

Ngen.exe har ett antal beroenden. Anta till exempel att MyAssembly.exe båda YourAssembly.exe är installerade i den interna avbildningscacheminnet och båda har referenser till OurDependency.dll. Om MyAssembly.exe avinstalleras OurDependency.dll avinstalleras inte. Den tas bara bort när YourAssembly.exe den också avinstalleras.

Om du genererar en intern avbildning för en sammansättning i den globala sammansättningscachen anger du dess visningsnamn. Se Assembly.FullName.

De interna avbildningar som Ngen.exe genererar kan delas mellan programdomäner. Det innebär att du kan använda Ngen.exe i programscenarier som kräver att sammansättningar delas mellan programdomäner. Så här anger du domänneutralitet:

• Använd attributet LoaderOptimizationAttribute för ditt program.

• Ange egenskapen AppDomainSetup.LoaderOptimization när du skapar konfigurationsinformation för en ny programdomän.

Använd alltid domänneutral kod när du läser in samma sammansättning i flera programdomäner. Om en intern avbildning läses in i en icke-delad programdomän efter att ha lästs in i en delad domän kan den inte användas.

I det här avsnittet Kommentarer:

• Generera avbildningar för olika scenarier

• Avgöra när inbyggda bilder ska användas

  • Förbättrad minnesanvändning

  • Snabbare programstart

  • Sammanfattning av användningsöverväganden

• Vikten av sammansättningsbasadresser

• Hård bindning

  • Ange ett bindningstips för ett beroende

  • Ange ett standardbindningstips för en sammansättning

• Uppskjuten bearbetning

• Interna avbildningar och JIT-kompilering

  • Ogiltiga bilder

• Felsökning

  • Loggvisningsprogram för sammansättningsbindning

  • JITCompilationStart hanterad felsökningsassistent

  • Avregistrera dig från den inbyggda bildgenereringen

Generera avbildningar för olika scenarier

När du har genererat en intern avbildning för en sammansättning försöker körningen automatiskt hitta och använda den här interna avbildningen varje gång den kör sammansättningen. Flera avbildningar kan genereras, beroende på användningsscenarier.

Om du till exempel kör en sammansättning i ett felsöknings- eller profileringsscenario letar körningen efter en intern avbildning som genererades med /Debug alternativen eller /Profile . Om det inte går att hitta en matchande intern avbildning återgår körningen till JIT-standardkompilering. Det enda sättet att felsöka interna avbildningar är att skapa en intern avbildning med alternativet /Debug .

Åtgärden uninstall identifierar även scenarier, så att du kan avinstallera alla scenarier eller endast valda scenarier.

Avgöra när inbyggda bilder ska användas

Interna avbildningar kan ge prestandaförbättringar inom två områden: förbättrad minnesanvändning och kortare starttid.

Förbättrad minnesanvändning

Interna avbildningar kan avsevärt förbättra minnesanvändningen när kod delas mellan processer. Interna avbildningar är Windows PE-filer, så en enda kopia av en .dll fil kan delas av flera processer. Däremot lagras intern kod som skapas av JIT-kompilatorn i privat minne och kan inte delas.

Program som körs under terminaltjänster kan också dra nytta av delade kodsidor.

Att inte läsa in JIT-kompilatorn sparar dessutom en fast mängd minne för varje programinstans.

Snabbare programstart

Förkompilering av sammansättningar med Ngen.exe kan förbättra starttiden för vissa program. I allmänhet kan vinster göras när program delar komponentsammansättningar eftersom de delade komponenterna redan har lästs in för efterföljande program när det första programmet har startats. Kall start, där alla sammansättningar i ett program måste läsas in från hårddisken, drar inte lika stor nytta av interna avbildningar eftersom hårddiskens åtkomsttid dominerar.

Hård bindning kan påverka starttiden eftersom alla avbildningar som är hårdbundna till huvudprogramsammansättningen måste läsas in samtidigt.

Sammanfattning av användningsöverväganden

Följande allmänna överväganden och programöverväganden kan hjälpa dig att avgöra om du ska utföra arbetet med att utvärdera inbyggda bilder för ditt program:

• Interna avbildningar läses in snabbare än CIL eftersom de eliminerar behovet av många startaktiviteter, till exempel JIT-kompilering och typsäkerhetsverifiering.

• Interna avbildningar kräver en mindre inledande arbetsuppsättning eftersom JIT-kompilatorn inte behöver det.

• Interna avbildningar möjliggör koddelning mellan processer.

• Interna avbildningar kräver mer hårddiskutrymme än CIL-sammansättningar och kan kräva mycket tid att generera.

• Interna avbildningar måste underhållas.

  • Avbildningar måste återskapas när den ursprungliga sammansättningen eller något av dess beroenden hanteras.

  • En enskild sammansättning kan behöva flera interna avbildningar för användning i olika program eller olika scenarier. Konfigurationsinformationen i två program kan till exempel resultera i olika bindningsbeslut för samma beroende sammansättning.

  • Interna avbildningar måste genereras av en administratör. det vill: från ett Windows-konto i gruppen Administratörer.

Utöver dessa allmänna överväganden måste programmets karaktär beaktas när du avgör om inbyggda bilder kan ge en prestandafördel:

• Om programmet körs i en miljö som använder många delade komponenter tillåter inbyggda avbildningar att komponenterna delas av flera processer.

• Om programmet använder flera programdomäner tillåter inbyggda avbildningar att kodsidor delas mellan domäner.

  Kommentar

  I .NET Framework-versionerna 1.0 och 1.1 kan interna avbildningar inte delas mellan programdomäner. Detta är inte fallet i version 2.0 eller senare.

• Om programmet körs under Terminal Server tillåter inbyggda avbildningar delning av kodsidor.

• Stora program drar vanligtvis nytta av kompilering till inbyggda avbildningar. Små program drar vanligtvis inte nytta av det.

• För långvariga program presterar JIT-kompilering under körning något bättre än interna avbildningar. (Hård bindning kan minska den här prestandaskillnaden i viss utsträckning.)

Vikten av sammansättningsbasadresser

Eftersom inbyggda avbildningar är Windows PE-filer, omfattas de av samma ombaseringsproblem som andra körbara filer. Prestandakostnaden för omlokalisering är ännu mer uttalad om hård bindning används.

Om du vill ange basadressen för en intern avbildning använder du lämpligt alternativ för kompilatorn för att ange basadressen för sammansättningen. Ngen.exe använder den här basadressen för den interna avbildningen.

Du kan använda ett verktyg som dumpbin.exe för att visa den primära basadressen för en intern avbildning.

Hård bindning

Hård bindning ökar dataflödet och minskar storleken på arbetsuppsättningen för interna bilder. Nackdelen med hård bindning är att alla avbildningar som är hårdbundna till en sammansättning måste läsas in när sammansättningen läses in. Detta kan avsevärt öka starttiden för ett stort program.

Hård bindning är lämplig för beroenden som läses in i alla programs prestandakritiska scenarier. Precis som med alla aspekter av intern bildanvändning är noggranna prestandamätningar det enda sättet att avgöra om hård bindning förbättrar programmets prestanda.

Med attributen DependencyAttribute och DefaultDependencyAttribute kan du ange hårda bindningstips för Ngen.exe.

Ange ett bindningstips för ett beroende

Använd på DependencyAttribute en sammansättning för att ange sannolikheten för att ett angivet beroende läses in. LoadHint.Always anger att hård bindning är lämplig, Default anger att standardvärdet för beroendet ska användas och Sometimes anger att hård bindning inte är lämplig.

Följande kod visar attributen för en sammansättning som har två beroenden. Det första beroendet (Assembly1) är en lämplig kandidat för hård bindning, och det andra (sammansättning2) är det inte.

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

Sammansättningsnamnet innehåller inte filnamnstillägget. Visningsnamn kan användas.

Ange ett standardbindningstips för en sammansättning

Standardbindningstips behövs bara för sammansättningar som används omedelbart och ofta av alla program som har ett beroende av dem. DefaultDependencyAttribute Använd med LoadHint.Always för sådana sammansättningar för att ange att hård bindning ska användas.

Microsoft använder DefaultDependencyAttribute för att ange att hård bindning är standard för ett mycket litet antal sammansättningar i .NET Framework, till exempel mscorlib.dll.

Uppskjuten bearbetning

Det kan ta lång tid att skapa interna avbildningar för ett mycket stort program. På samma sätt kan ändringar i en delad komponent eller ändringar i datorinställningarna kräva att många interna avbildningar uppdateras. Åtgärderna install och update har ett /queue alternativ som köar åtgärden för uppskjuten körning av den interna avbildningstjänsten. Dessutom har queue Ngen.exe och executeQueuedItems åtgärder som ger viss kontroll över tjänsten. Mer information finns i Intern avbildningstjänst.

Interna avbildningar och JIT-kompilering

Om Ngen.exe påträffar några metoder i en sammansättning som den inte kan generera, utesluter den dem från den interna avbildningen. När körningen kör den här sammansättningen återgår den till JIT-kompilering för de metoder som inte ingick i den interna avbildningen.

Dessutom används inte interna avbildningar om sammansättningen har uppgraderats eller om avbildningen har ogiltigförklarats av någon anledning.

Ogiltiga bilder

När du använder Ngen.exe för att skapa en intern avbildning av en sammansättning beror utdata på de kommandoradsalternativ som du anger och vissa inställningar på datorn. De här inställningarna omfattar följande:

• Versionen av .NET Framework.

• Den exakta identiteten för sammansättningen (omkompilering ändrar identitet).

• Den exakta identiteten för alla sammansättningar som sammansättningen refererar till (omkompilering ändrar identitet).

• Säkerhetsfaktorer.

Ngen.exe registrerar den här informationen när den genererar en intern avbildning. När du kör en sammansättning letar körningen efter den inbyggda avbildningen som genereras med alternativ och inställningar som matchar datorns aktuella miljö. Körningen återgår till JIT-kompilering av en sammansättning om den inte kan hitta en matchande intern avbildning. Följande ändringar i en dators inställningar och miljö gör att interna avbildningar blir ogiltiga:

• Versionen av .NET Framework.

  Om du tillämpar en uppdatering på .NET Framework blir alla interna avbildningar som du har skapat med Ngen.exe ogiltiga. Därför kör Ngen Update alla uppdateringar av .NET Framework kommandot för att säkerställa att alla inbyggda avbildningar återskapas. .NET Framework skapar automatiskt nya interna avbildningar för .NET Framework-biblioteken som installeras.

• Den exakta identiteten för sammansättningen.

  Om du kompilera om en sammansättning blir sammansättningens motsvarande interna avbildning ogiltig.

• Den exakta identiteten för alla sammansättningar sammansättningsreferenserna.

  Om du uppdaterar en hanterad sammansättning blir alla interna avbildningar som direkt eller indirekt är beroende av den sammansättningen ogiltiga och måste återskapas. Detta omfattar både vanliga referenser och hårdbundna beroenden. När en programuppdatering tillämpas ska installationsprogrammet köra ett Ngen Update kommando för att säkerställa att alla beroende interna avbildningar återskapas.

• Säkerhetsfaktorer.

  Om du ändrar datorns säkerhetsprincip för att begränsa behörigheter som tidigare beviljats till en sammansättning kan en tidigare kompilerad intern avbildning för sammansättningen bli ogiltig.

  Detaljerad information om hur common language runtime administrerar kodåtkomstsäkerhet och hur du använder behörigheter finns i Kodåtkomstsäkerhet.

Felsökning

I följande felsökningsavsnitt kan du se vilka interna avbildningar som används och vilka som inte kan användas av ditt program, för att avgöra när JIT-kompilatorn börjar kompilera en metod och visar hur du avregistrerar sig från intern bildkompilering av angivna metoder.

Loggvisningsprogram för sammansättningsbindning

Om du vill bekräfta att interna avbildningar används av ditt program kan du använda Fuslogvw.exe (Loggboken för sammansättningsbindning). Välj Interna avbildningar i rutan Loggkategorier i fönstret bindningsloggvisare. Fuslogvw.exe innehåller information om varför en intern avbildning avvisades.

JITCompilationStart hanterad felsökningsassistent

Du kan använda jitCompilationStart managed debugging assistant (MDA) för att avgöra när JIT-kompilatorn börjar kompilera en funktion.

Avregistrera dig från den inbyggda bildgenereringen

I vissa fall kan NGen.exe ha svårt att generera en intern avbildning för en viss metod, eller så kanske du föredrar att metoden är JIT-kompilerad i stället för att kompileras till en intern avbildning. I det här fallet kan du använda System.Runtime.BypassNGenAttribute attributet för att förhindra att NGen.exe genererar en intern avbildning för en viss metod. Attributet måste tillämpas individuellt på varje metod vars kod du inte vill inkludera i den interna avbildningen. NGen.exe identifierar attributet och genererar inte kod i den interna avbildningen för motsvarande metod.

Observera dock att det BypassNGenAttribute inte har definierats som en typ i .NET Framework-klassbiblioteket. För att kunna använda attributet i koden måste du först definiera det på följande sätt:

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

Du kan sedan använda attributet per metod. I följande exempel instrueras den interna avbildningsgeneratorn att den inte ska generera en intern avbildning för ExampleClass.ToJITCompile metoden.

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

Exempel

Följande kommando genererar en intern avbildning för ClientApp.exe, som finns i den aktuella katalogen, och installerar avbildningen i den interna avbildningscacheminnet. Om det finns en konfigurationsfil för sammansättningen använder Ngen.exe den. Dessutom genereras interna avbildningar för alla .dll filer som ClientApp.exe refererar till.

ngen install ClientApp.exe

En avbildning som installeras med Ngen.exe kallas också för en rot. En rot kan vara ett program eller en delad komponent.

Följande kommando genererar en intern avbildning för MyAssembly.exe med den angivna sökvägen.

ngen install c:\myfiles\MyAssembly.exe

När du lokaliserar sammansättningar och deras beroenden använder Ngen.exe samma avsökningslogik som används av den vanliga språkkörningen. Som standard används katalogen som innehåller ClientApp.exe som programbaskatalog och all sammansättningsavsökning börjar i den här katalogen. Du kan åsidosätta det här beteendet med hjälp /AppBase av alternativet .

En sammansättning kan ha ett beroende utan referens, till exempel om den läser in en .dll fil med hjälp Assembly.Load av metoden . Du kan skapa en intern avbildning för en sådan .dll fil med hjälp av konfigurationsinformation för programsammansättningen, med alternativet /ExeConfig . Följande kommando genererar en intern avbildning för MyLib.dll att använda konfigurationsinformationen från MyApp.exe.

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

Sammansättningar som är installerade på det här sättet tas inte bort när programmet tas bort.

Om du vill avinstallera ett beroende använder du samma kommandoradsalternativ som användes för att installera det. Följande kommando avinstallerar MyLib.dll från föregående exempel.

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

Om du vill skapa en intern avbildning för en sammansättning i den globala sammansättningscachen använder du sammansättningens visningsnamn. Till exempel:

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

NGen.exe genererar en separat uppsättning avbildningar för varje scenario som du installerar. Följande kommandon installerar till exempel en fullständig uppsättning interna avbildningar för normal drift, en annan fullständig uppsättning för felsökning och en tredje för profilering:

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

Visa den interna bildcachen

När interna avbildningar har installerats i cacheminnet kan de visas med hjälp av Ngen.exe. Följande kommando visar alla inbyggda avbildningar i den interna avbildningscacheminnet.

ngen display

Åtgärden display listar alla rotsammansättningar först, följt av en lista över alla interna avbildningar på datorn.

Använd det enkla namnet på en sammansättning om du bara vill visa information för den sammansättningen. Följande kommando visar alla interna avbildningar i den interna avbildningscache som matchar det partiella namnet MyAssembly, deras beroenden och alla rötter som har ett beroende av MyAssembly:

ngen display MyAssembly

Att veta vilka rötter som är beroende av en delad komponentsammansättning är användbart för att mäta effekten av en update åtgärd när den delade komponenten har uppgraderats.

Om du anger en sammansättnings filnamnstillägg måste du antingen ange sökvägen eller köra Ngen.exe från katalogen som innehåller sammansättningen:

ngen display c:\myApps\MyAssembly.exe

Följande kommando visar alla inbyggda avbildningar i den interna avbildningscachen med namnet MyAssembly och version 1.0.0.0.

ngen display "myAssembly, version=1.0.0.0"

Uppdatera bilder

Avbildningar uppdateras vanligtvis efter att en delad komponent har uppgraderats. Om du vill uppdatera alla inbyggda avbildningar som har ändrats eller vars beroenden har ändrats använder du update åtgärden utan argument.

ngen update

Att uppdatera alla bilder kan vara en lång process. Du kan köa uppdateringarna för körning av den interna avbildningstjänsten med hjälp /queue av alternativet . Mer information om /queue alternativ- och installationsprioriteringar finns i Intern avbildningstjänst.

ngen update /queue

Avinstallera bilder

Ngen.exe upprätthåller en lista över beroenden, så att delade komponenter endast tas bort när alla sammansättningar som är beroende av dem har tagits bort. Dessutom tas inte en delad komponent bort om den har installerats som en rot.

Följande kommando avinstallerar alla scenarier för roten ClientApp.exe:

ngen uninstall ClientApp

Åtgärden uninstall kan användas för att ta bort specifika scenarier. Följande kommando avinstallerar alla felsökningsscenarier för ClientApp.exe:

ngen uninstall ClientApp /debug

Följande kommando avinstallerar alla scenarier för en viss version av ClientApp.exe:

ngen uninstall "ClientApp, Version=1.0.0.0"

Följande kommandon avinstallerar alla scenarier för "ClientApp, Version=1.0.0.0, Culture=neutral, PublicKeyToken=3c7ba247adcd2081, processorArchitecture=MSIL", eller bara felsökningsscenariot för den sammansättningen:

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

Precis som med åtgärden install kräver tillhandahållandet av ett tillägg att antingen köra Ngen.exe från katalogen som innehåller sammansättningen eller ange en fullständig sökväg.

Exempel som relaterar till den interna avbildningstjänsten finns i Native Image Service(Intern avbildningstjänst).

Intern bilduppgift

Den interna avbildningsaktiviteten är en Windows-uppgift som genererar och underhåller interna avbildningar. Den inbyggda avbildningsuppgiften genererar och återtar interna avbildningar automatiskt för scenarier som stöds. Det gör det också möjligt för installationsprogram att använda Ngen.exe (inbyggd avbildningsgenerator) för att skapa och uppdatera interna avbildningar vid en uppskjuten tid.

Den interna avbildningsuppgiften registreras en gång för varje CPU-arkitektur som stöds på en dator för att tillåta kompilering för program som riktar sig till varje arkitektur:

Uppgiftsnamn	32-bitars dator	64-bitars dator
NET Framework NGEN v4.0.30319	Ja	Ja
NET Framework NGEN v4.0.30319 64	Nej	Ja

Den interna avbildningsuppgiften är tillgänglig i .NET Framework 4.5 och senare versioner när den körs i Windows 8 eller senare. I tidigare versioner av Windows använder .NET Framework den interna avbildningstjänsten.

Uppgiftslivslängd

I allmänhet startar Windows Task Scheduler den interna avbildningsaktiviteten varje kväll när datorn är inaktiv. Uppgiften söker efter uppskjutet arbete som placeras i kö av programinstallationsprogram, eventuella uppskjutna interna begäranden om avbildningsuppdateringar och alla automatiska avbildningsskapanden. Uppgiften slutför utestående arbetsobjekt och stängs sedan av. Om datorn slutar vara inaktiv medan aktiviteten körs stoppas aktiviteten.

Du kan också starta den interna avbildningsaktiviteten manuellt via användargränssnittet för schemaläggaren eller genom manuella anrop till NGen.exe. Om aktiviteten startas via någon av dessa metoder fortsätter den att köras när datorn inte längre är inaktiv. Avbildningar som skapas manuellt med hjälp av NGen.exe prioriteras för att aktivera förutsägbart beteende för programinstallationsprogram.

Intern avbildningstjänst

Den interna avbildningstjänsten är en Windows-tjänst som genererar och underhåller interna avbildningar. Med den interna avbildningstjänsten kan utvecklaren skjuta upp installationen och uppdateringen av interna avbildningar till perioder då datorn är inaktiv.

Normalt initieras den interna avbildningstjänsten av installationsprogrammet (installationsprogrammet) för ett program eller en uppdatering. För prioritet 3-åtgärder körs tjänsten under inaktiv tid på datorn. Tjänsten sparar sitt tillstånd och kan fortsätta genom flera omstarter om det behövs. Flera bildkompileringar kan placeras i kö.

Tjänsten interagerar också med det manuella kommandot Ngen.exe. Manuella kommandon har företräde framför bakgrundsaktivitet.

Starta uppskjutna åtgärder

Innan du påbörjar en installation eller uppgradering rekommenderar vi att du pausar tjänsten. Detta säkerställer att tjänsten inte körs medan installationsprogrammet kopierar filer eller placerar sammansättningar i den globala sammansättningscachen. Följande Ngen.exe kommandorad pausar tjänsten:

ngen queue pause

När alla uppskjutna åtgärder har placerats i kö tillåter följande kommando att tjänsten återupptas:

ngen queue continue

Om du vill skjuta upp den inbyggda avbildningsgenereringen install när du installerar ett nytt program eller när du uppdaterar en delad komponent använder du /queue alternativet med eller update -åtgärderna. Följande Ngen.exe kommandorader installerar en intern avbildning för en delad komponent och utför en uppdatering av alla rötter som kan ha påverkats:

ngen install MyComponent /queue
ngen update /queue

Åtgärden update återskapar alla inbyggda avbildningar som har ogiltigförklarats, inte bara de som använder MyComponent.

Om programmet består av många rötter kan du styra prioriteten för de uppskjutna åtgärderna. Följande kommandon köar installationen av tre rötter. Assembly1 installeras först, utan att vänta på inaktiv tid. Assembly2 installeras också utan att vänta på inaktiv tid, men när alla prioritet 1-åtgärder har slutförts. Assembly3 installeras när tjänsten upptäcker att datorn är inaktiv.

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

Du kan tvinga köade åtgärder att ske synkront med hjälp av åtgärden executeQueuedItems . Om du anger den valfria prioriteten påverkar den här åtgärden endast de köade åtgärder som har samma eller lägre prioritet. Standardprioriteten är 3, så följande Ngen.exe kommando bearbetar alla köade åtgärder omedelbart och returnerar inte förrän de är klara:

ngen executeQueuedItems

Synkrona kommandon körs av Ngen.exe och använder inte den interna avbildningstjänsten. Du kan köra åtgärder med hjälp av Ngen.exe medan den interna avbildningstjänsten körs.

Tjänstavstängning

När du har initierats av körningen av ett Ngen.exe kommando som innehåller /queue alternativet körs tjänsten i bakgrunden tills alla åtgärder har slutförts. Tjänsten sparar sitt tillstånd så att den kan fortsätta genom flera omstarter om det behövs. När tjänsten upptäcker att det inte finns några fler åtgärder i kö återställs dess status så att den inte startas om nästa gång datorn startas och sedan stängs den av.

Tjänstinteraktion med klienter

I .NET Framework version 2.0 är den enda interaktionen med den interna avbildningstjänsten via kommandoradsverktyget Ngen.exe. Använd kommandoradsverktyget i installationsskript för att köa åtgärder för den interna avbildningstjänsten och för att interagera med tjänsten.

Se även

• Verktyg
• Hanterad körningsprocess
• Så här letar Runtime upp sammansättningar
• Kommandoradsgränssnitt för utvecklare