ASP.NET Compilazione Blazor WebAssembly core e compilazione anticipata (AOT)

Questo articolo descrive gli strumenti di compilazione per le app autonome Blazor WebAssembly e come compilare un'app prima della distribuzione con compilazione anticipata (AOT).

Anche se l'articolo è incentrato principalmente sulle app autonome Blazor WebAssembly , la sezione relativa alle dimensioni dell'heap per alcuni browser per dispositivi mobili si applica anche al progetto lato client (.Client) di un oggetto Blazor Web App.

Strumenti di compilazione WebAssembly .NET

Gli strumenti di compilazione .NET WebAssembly sono basati su Emscripten, una toolchain del compilatore per la piattaforma Web. Per installare gli strumenti di compilazione, usare uno degli approcci seguenti:

• Per il carico di lavoro ASP.NET e sviluppo Web nel programma di installazione di Visual Studio, selezionare l'opzione Strumenti di compilazione .NET WebAssembly dall'elenco dei componenti facoltativi.
• Eseguire dotnet workload install wasm-tools in una shell dei comandi amministrativa.

Nota

Strumenti di compilazione .NET WebAssembly per progetti .NET 6

Il wasm-tools carico di lavoro installa gli strumenti di compilazione per la versione più recente. Tuttavia, la versione corrente degli strumenti di compilazione non è compatibile con i progetti esistenti compilati con .NET 6. I progetti che usano gli strumenti di compilazione che devono supportare sia .NET 6 che una versione successiva devono usare multitargeting.

Usare il wasm-tools-net6 carico di lavoro per i progetti .NET 6 durante lo sviluppo di app con .NET 7 SDK. Per installare il wasm-tools-net6 carico di lavoro, eseguire il comando seguente da una shell dei comandi amministrativa:

dotnet workload install wasm-tools-net6

Compilazione anticipata (AOT)

Blazor WebAssembly supporta la compilazione anticipata (AOT), in cui è possibile compilare il codice .NET direttamente in WebAssembly. La compilazione AOT comporta miglioramenti delle prestazioni di runtime a scapito di dimensioni maggiori dell'app.

Senza abilitare la compilazione AOT, Blazor WebAssembly le app vengono eseguite nel browser usando un interprete .NET Intermediate Language (IL) implementato in WebAssembly con supporto di runtime JIT parziale, noto in modo informale come Jiterpreter. Poiché il codice .NET IL viene interpretato, le app vengono in genere eseguite più lentamente rispetto a quelle eseguite in un runtime JIT .NET lato server senza alcuna interpretazione IL. La compilazione AOT risolve questo problema di prestazioni compilando il codice .NET di un'app direttamente in WebAssembly per l'esecuzione nativa di WebAssembly dal browser. Il miglioramento delle prestazioni AOT può produrre miglioramenti notevoli per le app che eseguono attività a elevato utilizzo di CPU. Lo svantaggio dell'uso della compilazione AOT è che le app compilate da AOT sono in genere più grandi delle controparti interpretate con IL, quindi in genere richiedono più tempo per il download nel client quando richiesto per la prima volta.

Per indicazioni sull'installazione degli strumenti di compilazione WebAssembly .NET, vedere ASP.NET Core Blazor WebAssembly build tools and ahead-of-time (AOT).

Per abilitare la compilazione WebAssembly AOT, aggiungere la <RunAOTCompilation> proprietà impostata al true Blazor WebAssembly file di progetto dell'app:

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

Per compilare l'app in WebAssembly, pubblicare l'app. La pubblicazione della Release configurazione garantisce che venga eseguito anche il collegamento .NET Intermediate Language (IL) per ridurre le dimensioni dell'app pubblicata:

dotnet publish -c Release

La compilazione AOT webAssembly viene eseguita solo quando il progetto viene pubblicato. La compilazione AOT non viene usata quando il progetto viene eseguito durante lo sviluppo (Development ambiente) perché la compilazione AOT richiede in genere alcuni minuti su progetti di piccole dimensioni e potenzialmente molto più lunga per i progetti più grandi. La riduzione del tempo di compilazione per la compilazione AOT è in fase di sviluppo per le versioni future di ASP.NET Core.

Le dimensioni di un'app compilata Blazor WebAssembly con AOT sono in genere superiori alle dimensioni dell'app se compilate in .NET IL:

• Anche se la differenza di dimensioni dipende dall'app, la maggior parte delle app compilate da AOT è circa il doppio delle dimensioni delle versioni compilate con IL. Ciò significa che l'uso della compilazione AOT impedisce le prestazioni in fase di caricamento per le prestazioni di runtime. Se questo compromesso vale la pena usare la compilazione AOT dipende dalla tua app. Blazor WebAssembly le app che richiedono un utilizzo intensivo della CPU in genere traggono il maggior vantaggio dalla compilazione AOT.

• Le dimensioni maggiori di un'app compilata con AOT sono dovute a due condizioni:

  • È necessario altro codice per rappresentare istruzioni .NET il di alto livello in WebAssembly nativo.
  • AOT non elimina le DLL gestite quando l'app viene pubblicata. Blazor richiede le DLL per i metadati di reflection e per supportare determinate funzionalità di runtime .NET. La richiesta delle DLL nel client aumenta le dimensioni del download, ma offre un'esperienza .NET più compatibile.

Nota

Per le proprietà e le destinazioni di MSBuild mono/WebAssembly, vedere WasmApp.Common.targets (dotnet/runtime repository GitHub). La documentazione ufficiale per le proprietà comuni di MSBuild è pianificata per le opzioni di configurazione msbuild del documento blazor (dotnet/docs #27395)..

Trim .NET IL after-of-time (AOT) compilation

L'opzione WasmStripILAfterAOT MSBuild consente di rimuovere .NET Intermediate Language (IL) per i metodi compilati dopo l'esecuzione della compilazione AOT in WebAssembly, riducendo così le dimensioni della _framework cartella.

Nel file di progetto dell'app:

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

Questa impostazione elimina il codice IL per la maggior parte dei metodi compilati, inclusi i metodi delle librerie e dei metodi nell'app. Non tutti i metodi compilati possono essere eliminati, perché alcuni sono ancora richiesti dall'interprete .NET in fase di esecuzione.

Per segnalare un problema con l'opzione di taglio, aprire un problema nel dotnet/runtime repository GitHub.

Disabilitare la proprietà trimming se impedisce l'esecuzione normale dell'app:

<WasmStripILAfterAOT>false</WasmStripILAfterAOT>

Dimensioni dell'heap per alcuni browser per dispositivi mobili

Quando si compila un'app Blazor eseguita nel client e si rivolge ai browser per dispositivi mobili, in particolare Safari in iOS, è possibile che sia necessaria una riduzione della memoria massima per l'app con la proprietà EmccMaximumHeapSize MSBuild. Per altre informazioni, vedere Ospitare e distribuire ASP.NET Core Blazor WebAssembly.

Ricollegamento del runtime

Una delle parti più grandi di un'app Blazor WebAssembly è il runtime .NET basato su WebAssembly (dotnet.wasm) che il browser deve scaricare quando l'app è accessibile per la prima volta dal browser di un utente. Il ricollegamento del runtime .NET WebAssembly riduce il codice di runtime inutilizzato e quindi migliora la velocità di download.

Per il ricollegamento in fase di esecuzione è necessaria l'installazione degli strumenti di compilazione .NET WebAssembly. Per altre informazioni, vedere Strumenti per ASP.NET Core Blazor.

Con gli strumenti di compilazione .NET WebAssembly installati, il ricollegamento del runtime viene eseguito automaticamente quando un'app viene pubblicata nella Release configurazione. La riduzione delle dimensioni è particolarmente drammatica quando si disabilita la globalizzazione. Per altre informazioni, vedere ASP.NET Globalizzazione e localizzazione di coreBlazor.

Importante

Il ricollegamento del runtime riduce i metodi JavaScript-invokable dell'istanza della classe a meno che non siano protetti. Per altre informazioni, vedere Chiamare metodi .NET da funzioni JavaScript in ASP.NET Core Blazor.

Singola istruzione, più dati (SIMD)

Blazor usa WebAssembly Single Instruction, Multiple Data (SIMD) per migliorare la velocità effettiva dei calcoli vettorializzati eseguendo un'operazione su più parti di dati in parallelo usando una singola istruzione.

Per disabilitare SIMD, ad esempio quando la destinazione è destinata a browser o browser obsoleti nei dispositivi mobili che non supportano SIMD, impostare la <WasmEnableSIMD> proprietà su false nel file di progetto dell'app (.csproj):

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

Per altre informazioni, vedere Configurazione e hosting di applicazioni WebAssembly .NET: SIMD - Singola istruzione, più dati e si noti che le indicazioni non vengono rilasciate e si applicano alla versione pubblica più recente.

Gestione delle eccezioni

La gestione delle eccezioni è abilitata per impostazione predefinita. Per disabilitare la gestione delle eccezioni, aggiungere la <WasmEnableExceptionHandling> proprietà con un valore di false nel file di progetto dell'app (.csproj):

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

Per ulteriori informazioni, vedi le seguenti risorse:

• Configurazione e hosting di applicazioni WebAssembly .NET: EH - Gestione delle eccezioni
• Gestione delle eccezioni

Risorse aggiuntive

• dipendenze native di ASP.NET Core Blazor WebAssembly
• Formato di creazione di pacchetti Webcil per assembly .NET