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

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).

Även om artikeln främst fokuserar på fristående Blazor WebAssembly appar, gäller avsnittet om heapstorlek för vissa mobila enhetswebbläsare även för projektet på klientsidan (.Client) för en Blazor Web App.

Byggverktyg för .NET WebAssembly

Byggverktygen för .NET WebAssembly baseras på Emscripten, en kompilatorverktygskedja för webbplattformen. Om du vill installera byggverktygen använder du antingen 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.
• Kör dotnet workload install wasm-tools i ett administrativt kommandogränssnitt.

Not

.NET WebAssembly-byggverktyg för .NET 6-projekt

Arbetsbelastningen wasm-tools installerar byggverktygen för den senaste utgåvan. Den aktuella versionen av byggverktygen är dock inte kompatibel med befintliga projekt som skapats med .NET 6. Projekt som använder byggverktygen och behöver stödja både .NET 6 och en senare version måste använda flermålsinriktning.

Använd arbetsbelastningen wasm-tools-net6 för .NET 6-projekt när du utvecklar appar med .NET 7 SDK. Installera arbetsbelastningen wasm-tools-net6 genom att köra följande kommando från ett administrativt kommandogränssnitt:

dotnet workload install wasm-tools-net6

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.

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.

Anteckning

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).

Trimma .NET IL efter AOT-kompilering (i förväg)

Med alternativet WasmStripILAfterAOT MSBuild kan du ta bort .NET Intermediate Language (IL) för kompilerade metoder efter att ha utfört AOT-kompilering till WebAssembly, vilket minskar storleken på mappen _framework.

I applikationens projektfil:

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

Den här inställningen trimmar bort IL-koden för de flesta kompilerade metoder, inklusive metoder från bibliotek och metoder i appen. Alla kompilerade metoder kan inte trimmas eftersom vissa fortfarande krävs av .NET-tolken vid körning.

Om du vill rapportera ett problem med trimningsalternativet öppna ett problem på dotnet/runtime GitHub-lagringsplatsen.

Inaktivera trimningsegenskapen om den förhindrar att appen körs normalt:

<WasmStripILAfterAOT>false</WasmStripILAfterAOT>

Heapstorlek för vissa webbläsare för mobila enheter

När du skapar en Blazor app som körs på klienten och riktar sig till mobila enhetswebbläsare, särskilt Safari i iOS, kan det krävas att du minskar det maximala minnet för appen med egenskapen MSBuild EmccMaximumHeapSize. Mer information finns i Värd och distribuera ASP.NET Core Blazor WebAssembly.

Relänkning vid körtid

En av de största delarna i en Blazor WebAssembly app är den WebAssembly-baserade .NET-körningen (dotnet.wasm) som webbläsaren måste ladda ned när appen först nås av en användares webbläsare. Genom att länka om .NET WebAssembly-runtime trimmas den oanvända runtime-koden, vilket förbättrar nedladdningshastigheten.

Körningstidens omlänkning kräver installation av .NET WebAssembly-byggverktygen. Mer information finns i Tooling for ASP.NET Core Blazor.

När byggverktygen för .NET WebAssembly har installerats, sker omlänkning av programtidsbiblioteket automatiskt när en app publiceras i den konfiguration som Release. Storleksminskningen är särskilt dramatisk när globaliseringen inaktiveras. Mer information finns i ASP.NET Core Blazor globalisering och lokalisering.

Viktig

Körningsåterlänkning trimmar klassinstansen JavaScript-anropande .NET-metoder om de inte är skyddade. Mer information finns i Anropa .NET-metoder från JavaScript-funktioner i ASP.NET Core Blazor.

Enkel instruktion, flera data (SIMD)

Blazor använder WebAssembly Single Instruction, Multiple Data (SIMD) för att förbättra dataflödet för vektoriserade beräkningar genom att utföra en åtgärd på flera datadelar parallellt med hjälp av en enda instruktion.

Om du vill inaktivera SIMD, till exempel när du riktar in dig på gamla webbläsare eller webbläsare på mobila enheter som inte stöder SIMD, ställer du in egenskapen <WasmEnableSIMD> på false i appens projektfil (.csproj):

<PropertyGroup>
  <WasmEnableSIMD>false</WasmEnableSIMD>
</PropertyGroup>

Mer information finns i Konfigurera och vara värd för .NET WebAssembly-program: SIMD – Enkel instruktion, flera data och observera att vägledningen inte är versionshanterad och gäller för den senaste offentliga versionen.

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>

Mer information finns i följande resurser:

• Konfigurera och vara värd för .NET WebAssembly-program: EH – Undantagshantering
• Undantagshantering

Ytterligare resurser

• ASP.NET Core Blazor WebAssembly inbyggda beroenden
• Webcil-paketeringsformat för .NET-sammansättningar