Dela via

ASP.NET Core Blazor WebAssembly kompileringsverktyg och AOT-kompilering (i förväg)

Notis

Det här är inte den senaste versionen av den här artikeln. Den aktuella utgåvan finns i den .NET 9-versionen av den här artikeln.

Varning

Den här versionen av ASP.NET Core stöds inte längre. Mer information finns i .NET och .NET Core Support Policy. Den aktuella utgåvan finns i den .NET 9-versionen av den här artikeln.

Viktig

Den här informationen gäller en förhandsversionsprodukt som kan ändras avsevärt innan den släpps kommersiellt. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, med avseende på den information som tillhandahålls här.

Den aktuella utgåvan finns i den .NET 9-versionen av den här artikeln.

Den här artikeln beskriver byggverktygen för fristående Blazor WebAssembly appar och hur du kompilerar en app före distributionen med AOT-kompilering (i förväg).

Byggverktyg för .NET WebAssembly

Byggverktygen för .NET WebAssembly baseras på Emscripten, en kompilatorverktygskedja för webbplattformen.

Om du vill installera byggverktygen som en .NET-arbetsbelastning använder du någon av följande metoder:

  • För arbetsbelastningen ASP.NET och webbutveckling i Visual Studio-installationsprogrammet väljer du .NET WebAssembly-byggverktyg i listan med valfria komponenter. Alternativet säkerställer följande:

    • Arbetsbelastningen installeras för den senaste .NET SDK:t.
    • När en ny version av Visual Studio släpps och den innehåller en ny .NET SDK, installerar alternativet arbetsbelastningen för det nya SDK:t.

  • Du kan också köra följande kommando i ett administrativt kommandogränssnitt för att installera den senaste arbetsbelastningen till den senaste .NET SDK som är tillgänglig i systemet:

    dotnet workload install wasm-tools

Om du vill rikta in en tidigare version av .NET med en viss .NET SDK installerar du arbetsbelastningen wasm-tools-net{MAJOR VERSION} :

  • Platshållaren {MAJOR VERSION} ersätts med huvudversionsnumret för den .NET-version som du vill rikta in dig på (till exempel wasm-tools-net8 för .NET 8).
  • Arbetslaster installeras per .NET SDK. Om du installerar arbetsbelastningen wasm-tools för en SDK blir den inte tillgänglig för andra SDK:er i systemet.
  • Du måste installera lämplig arbetsbelastning för varje .NET SDK-version som du tänker använda.

I följande lista visas vilken arbetsbelastning som ska installeras för varje .NET SDK, beroende på vilka appar som du planerar att rikta in dig på. Även om flera rader kan innehålla samma arbetsbelastningsnamn skiljer sig arbetsbelastningarna alltid något åt för varje specifik .NET SDK.

  • Använda .NET 9 SDK
    • Att rikta in sig på .NET 9 kräver wasm-tools.
    • Att rikta in sig på .NET 8 kräver wasm-tools-net8.
  • Användning av .NET 8 SDK: För .NET 8 krävs wasm-tools.

AOT-kompilering (förhandskompilering)

Blazor WebAssembly stöder AOT-kompilering (i förväg) där du kan kompilera .NET-koden direkt till WebAssembly. AOT-kompilering resulterar i förbättrad prestanda vid körning men leder till att appens storlek ökar.

Utan att aktivera AOT-kompilering körs Blazor WebAssembly appar i webbläsaren med hjälp av en .NET Intermediate Language (IL) tolk implementerad i WebAssembly med partiell just-in-time (JIT) runtime-stöd, som informellt kallas Jiterpreter. Eftersom .NET IL-koden tolkas körs appar vanligtvis långsammare än på en .NET JIT-körning på serversidan utan någon IL-tolkning. AOT-kompilering åtgärdar det här prestandaproblemet genom att kompilera en apps .NET-kod direkt till WebAssembly för intern WebAssembly-körning av webbläsaren. Prestandaförbättringen för AOT kan ge dramatiska förbättringar för appar som utför processorintensiva uppgifter. Nackdelen med att använda AOT-kompilering är att AOT-kompilerade appar i allmänhet är större än deras IL-tolkade motsvarigheter, så de tar vanligtvis längre tid att ladda ned till klienten när de först begärs.

Utan att aktivera AOT-kompilering körs Blazor WebAssembly appar i webbläsaren med hjälp av en .NET Intermediate Language (IL) tolk som implementerats i WebAssembly. Eftersom .NET-koden tolkas, körs appar vanligtvis långsammare än om de körs med en serverside .NET-just-in-time (JIT) körmiljö. AOT-kompilering åtgärdar det här prestandaproblemet genom att kompilera en apps .NET-kod direkt till WebAssembly för intern WebAssembly-körning av webbläsaren. Prestandaförbättringen för AOT kan ge dramatiska förbättringar för appar som utför processorintensiva uppgifter. Nackdelen med att använda AOT-kompilering är att AOT-kompilerade appar i allmänhet är större än deras IL-tolkade motsvarigheter, så de tar vanligtvis längre tid att ladda ned till klienten när de först begärs.

Vägledning om hur du installerar .NET WebAssembly-byggverktygen finns i ASP.NET Core Blazor WebAssembly byggverktyg och "ahead-of-time" (AOT) kompilering.

Om du vill aktivera WebAssembly AOT-kompilering lägger du till egenskapen <RunAOTCompilation> inställd på true i Blazor WebAssembly-appens projektfil:

<PropertyGroup>
  <RunAOTCompilation>true</RunAOTCompilation>
</PropertyGroup>

Publicera appen för att kompilera appen till WebAssembly. Genom att publicera Release-konfigurationen säkerställer du att il-länken (.NET Intermediate Language) också körs för att minska storleken på den publicerade appen:

dotnet publish -c Release

WebAssembly AOT-kompilering utförs endast när projektet publiceras. AOT-kompilering används inte när projektet körs under utveckling (Development miljö) eftersom AOT-kompilering vanligtvis tar flera minuter på små projekt och potentiellt mycket längre för större projekt. Att minska byggtiden för AOT-kompilering är under utveckling för framtida versioner av ASP.NET Core.

Storleken på en AOT-kompilerad Blazor WebAssembly app är vanligtvis större än storleken på appen om den kompileras till .NET IL:

  • Även om storleksskillnaden beror på appen är de flesta AOT-kompilerade appar ungefär dubbelt så stora som deras IL-kompilerade versioner. Det innebär att användning av AOT-kompilering byter laddningstidsprestanda mot körtidsprestanda. Om den här kompromissen är värd att använda AOT-kompilering beror på din app. Blazor WebAssembly appar som är processorintensiva drar vanligtvis mest nytta av AOT-kompilering.

  • Den större storleken på en AOT-kompilerad app beror på två villkor:

    • Mer kod krävs för att representera .NET IL-instruktioner på hög nivå i den interna WebAssembly.
    • AOT trimmar inte ut hanterade DLL:er när appen publiceras. Blazor kräver DLL-filer för reflektionsmetadata och för att stödja vissa specifika .NET-körningsfunktioner. Om du kräver DLL:er på klienten ökar nedladdningsstorleken men ger en mer kompatibel .NET-upplevelse.

Notis

För egenskaper och mål för Mono/WebAssembly MSBuild, se WasmApp.Common.targets (dotnet/runtime GitHub-lagringsplats). Officiell dokumentation för vanliga MSBuild-egenskaper planeras enligt Dokumentation av Blazor MSBuild-konfigurationsalternativ (dotnet/docs #27395).

Prestanda

Mer information om prestanda finns i ASP.NET Core-körningsprestandaBlazor WebAssembly:

  • Heapstorlek för vissa webbläsare för mobila enheter
  • Relänkning vid körtid
  • Enkel instruktion, flera data (SIMD)
  • Trimma .NET IL efter AOT-kompilering (.NET 8 eller senare)

Undantagshantering

Undantagshantering är aktiverat som standard. Om du vill inaktivera undantagshantering lägger du till egenskapen <WasmEnableExceptionHandling> med värdet false i appens projektfil (.csproj):

<PropertyGroup>
  <WasmEnableExceptionHandling>false</WasmEnableExceptionHandling>
</PropertyGroup>

Om du vill aktivera WebAssembly-undantagshantering lägger du till egenskapen <WasmEnableExceptionHandling> med värdet true i appens projektfil (.csproj):

<PropertyGroup>
  <WasmEnableExceptionHandling>true</WasmEnableExceptionHandling>
</PropertyGroup>

Mer information finns i följande resurser:

Ytterligare resurser