Distribuzione AOT nativa

  • Articolo

La pubblicazione dell'app come AOT nativa genera un'app autonoma e compilata in anticipo nel codice nativo. Le app AOT native hanno tempi di avvio più rapidi e footprint di memoria più piccoli. Queste app possono essere eseguite nei computer in cui non è installato il runtime .NET.

Il vantaggio di AOT nativo è molto significativo per i carichi di lavoro con un numero elevato di istanze distribuite, ad esempio l'infrastruttura cloud e i servizi con iperscalabilità. .NET 8 aggiunge il supporto di ASP.NET Core per AOT nativo.

Il modello di distribuzione AOT nativo usa un compilatore in anticipo per compilare IL in codice nativo al momento della pubblicazione. Le app AOT native non usano un compilatore JIT (Just-In-Time) quando l'applicazione viene eseguita. Le app AOT native possono essere eseguite in ambienti con restrizioni in cui non è consentito un JIT. Le applicazioni AOT native sono destinate a un ambiente di runtime specifico, ad esempio Linux x64 o Windows x64, proprio come la pubblicazione di un'app autonoma.

Limitazioni nel modello di distribuzione AOT di .NET Native

L'AOT nativo è destinato alle app di tipo console. Solo un numero limitato di librerie è completamente compatibile con AOT nativo.

Prerequisiti

Visual Studio 2022, incluso il carico di lavoro sviluppo di desktop con C++ con tutti i componenti predefiniti.

Pubblicare AOT nativo usando l'interfaccia della riga di comando

  1. Aggiungere <PublishAot>true</PublishAot> al file di progetto.

    Questa proprietà abilita la compilazione AOT nativa durante la pubblicazione. Consente anche l'analisi dinamica dell'utilizzo del codice durante la compilazione e la modifica. È preferibile inserire questa impostazione nel file di progetto anziché passarla alla riga di comando, perché controlla i comportamenti all'esterno della pubblicazione.

    <PropertyGroup>
    <PublishAot>true</PublishAot>
</PropertyGroup>

  2. Pubblicare l'app per un identificatore di runtime specifico usando dotnet publish -r <RID>.

    L'esempio seguente pubblica l'app per Windows come applicazione AOT nativa in un computer con i prerequisiti necessari installati.

    dotnet publish -r win-x64 -c Release

    L'esempio seguente pubblica l'app per Linux come applicazione AOT nativa. Un file binario AOT nativo prodotto nel computer Linux funziona solo nella stessa versione Linux o successiva. Ad esempio, il file binario AOT nativo prodotto in Ubuntu 20.04 verrà eseguito in Ubuntu 20.04 e versioni successive, ma non verrà eseguito in Ubuntu 18.04.

    dotnet publish -r linux-arm64 -c Release

L'app è disponibile nella directory di pubblicazione e contiene tutto il codice necessario per eseguirlo, inclusa una versione rimossa del runtime coreclr.

Vedere gli esempi AOT nativi disponibili nel repository dotnet/samples in GitHub. Gli esempi includono Linux e Windows Dockerfile che illustrano come automatizzare l'installazione dei prerequisiti e pubblicare progetti .NET con AOT nativo usando contenitori.

Analizzatori di compatibilità AOT

Gli analizzatori di compatibilità AOT sono disponibili solo in .NET 8 e versioni successive.

Informazioni di debug native

La pubblicazione AOT nativa segue le convenzioni della piattaforma per le toolchain native. Il comportamento predefinito delle toolchain native in Windows consiste nel produrre informazioni di debug in un file con estensione pdb separato. Il comportamento predefinito delle toolchain native in Linux consiste nell'includere le informazioni di debug nel file binario nativo, che rende il file binario nativo più grande.

Impostare la StripSymbolsproprietà su true per produrre le informazioni di debug in un file separato dbg ed escluderlo dal file binario nativo in Linux. Questa proprietà non ha alcun effetto su Windows.

<PropertyGroup>
    <StripSymbols>true</StripSymbols>
</PropertyGroup>

Limitazioni della distribuzione AOT nativa

Le app AOT native presentano le limitazioni seguenti:

  • Nessun caricamento dinamico, Assembly.LoadFilead esempio .
  • Nessuna generazione di codice in fase di esecuzione, ad esempio System.Reflection.Emit.
  • Nessun C++/CLI.
  • Windows: nessun COM predefinito.
  • Richiede il taglio, che presenta limitazioni.
  • Implica la compilazione in un singolo file, con incompatibilità note.
  • Le app includono librerie di runtime necessarie (proprio come app autonome, aumentandone le dimensioni rispetto alle app dipendenti dal framework).
  • System.Linq.Expressions usano sempre il formato interpretato, che è più lento rispetto al codice compilato generato in fase di esecuzione.
  • Non tutte le librerie di runtime sono completamente annotate per essere compatibili con AOT nativo. Ovvero, alcuni avvisi nelle librerie di runtime non sono utilizzabili dagli sviluppatori finali.

Il processo di pubblicazione analizza l'intero progetto e le relative dipendenze per individuare eventuali limitazioni. Gli avvisi vengono generati per ogni limitazione che l'app pubblicata può riscontrare in fase di esecuzione.

Limitazioni specifiche della versione

  • Deve essere destinato alle app con tipo di console. ASP.NET Core non è supportato.
  • Supporto diagnostico limitato per il debug e la profilatura.

Creare librerie native

La pubblicazione di librerie di classi .NET come AOT nativo consente di creare librerie utilizzabili da linguaggi di programmazione non-.NET. La libreria nativa prodotta è autonoma e non richiede l'installazione di un runtime .NET.

La pubblicazione di una libreria di classi come AOT nativo crea una libreria nativa che espone i metodi della libreria di classi annotati con UnmanagedCallersOnlyAttribute con un campo EntryPoint non Null. Per altre informazioni, vedere l'esempio di libreria nativa disponibile nel repository dotnet/samples in GitHub.

Limitazioni relative alla piattaforma/architettura

La tabella seguente mostra le destinazioni di compilazione supportate.

Piattaforma Architettura supportata
Finestre x64, Arm64
Linux x64, Arm64