Panoramica della pubblicazione di applicazioni .NET

  • Articolo
  • 8 minuti per la lettura

Le applicazioni create con .NET possono essere pubblicate in due modalità diverse e la modalità influisce sul modo in cui un utente esegue l'app.

La pubblicazione dell'app come autonoma produce un'applicazione che include il runtime e le librerie .NET e l'applicazione e le relative dipendenze. Gli utenti dell'applicazione possono eseguirla in un computer in cui non è installato il runtime .NET.

La pubblicazione dell'app come dipendente dal framework produce un'applicazione che include solo l'applicazione stessa e le relative dipendenze. Gli utenti dell'applicazione devono installare separatamente il runtime .NET.

Entrambe le modalità di pubblicazione producono un eseguibile specifico della piattaforma per impostazione predefinita. Le applicazioni dipendenti dal framework possono essere create senza un eseguibile e queste applicazioni sono multipiattaforma.

Quando viene prodotto un eseguibile, è possibile specificare la piattaforma di destinazione con un identificatore di runtime (RID). Per altre informazioni sui RID, vedere Catalogo RID .NET.

La tabella seguente illustra i comandi usati per pubblicare un'app come dipendente dal framework o indipendente, in base alla versione dell'SDK:

Tipo SDK 2.1 SDK 3.1 SDK 5.0 SDK 6.0 Comando
Eseguibile dipendente dal framework per la piattaforma corrente. ✔️ ✔️ ✔️ dotnet publish
eseguibile dipendente dal framework per una piattaforma specifica. ✔️ ✔️ ✔️ dotnet publish -r <RID> --self-contained false
binario multipiattaforma dipendente dal framework. ✔️ ✔️ ✔️ ✔️ dotnet publish
eseguibile indipendente. ✔️ ✔️ ✔️ ✔️ dotnet publish -r <RID>

Per altre informazioni, vedere Comando dotnet publish .NET.

Produrre un file eseguibile

I file eseguibili non sono multipiattaforma. Sono specifici di un sistema operativo e di un'architettura della CPU. Quando si pubblica l'app e si crea un file eseguibile, è possibile pubblicare l'app come indipendente o dipendente dal framework. La pubblicazione di un'app come autonoma include il runtime .NET con l'app e gli utenti dell'app non devono preoccuparsi di installare .NET prima di eseguire l'app. Le app pubblicate come dipendenti dal framework non includono il runtime e le librerie .NET. sono incluse solo l'app e le dipendenze di terze parti.

I comandi seguenti producono un eseguibile:

Tipo SDK 2.1 SDK 3.1 SDK 5.0 SDK 6.0 Comando
Eseguibile dipendente dal framework per la piattaforma corrente. ✔️ ✔️ ✔️ dotnet publish
eseguibile dipendente dal framework per una piattaforma specifica. ✔️ ✔️ ✔️ dotnet publish -r <RID> --self-contained false
eseguibile indipendente. ✔️ ✔️ ✔️ ✔️ dotnet publish -r <RID>

Produrre un file binario multipiattaforma

I file binari multipiattaforma vengono creati quando si pubblica l'app come dipendente dal framework, sotto forma di file DLL . Il file DLL è denominato in base al progetto. Ad esempio, se si ha un'app denominata word_reader, viene creato un file denominato word_reader.dll . Le app pubblicate in questo modo vengono eseguite con il dotnet <filename.dll> comando e possono essere eseguite in qualsiasi piattaforma.

I file binari multipiattaforma possono essere eseguiti in qualsiasi sistema operativo, purché il runtime .NET di destinazione sia già installato. Se il runtime .NET di destinazione non è installato, l'app può essere eseguita usando un runtime più recente se l'app è configurata per il roll forward. Per altre informazioni, vedere Roll forward delle app dipendenti dal framework.

Il comando seguente produce un file binario multipiattaforma:

Tipo SDK 2.1 SDK 3.x SDK 5.0 SDK 6.0 Comando
binario multipiattaforma dipendente dal framework. ✔️ ✔️ ✔️ ✔️ dotnet publish

Pubblicare dipendenti dal framework

Le app pubblicate come dipendenti dal framework sono multipiattaforma e non includono il runtime .NET. L'utente dell'app è necessario per installare il runtime .NET.

La pubblicazione di un'app come dipendente dal framework produce un file binario multipiattaforma come file DLL e un eseguibile specifico della piattaforma destinato alla piattaforma corrente. La DLL è multipiattaforma mentre l'eseguibile non lo è. Ad esempio, se si pubblica un'app denominata word_reader e destinazione Windows, viene creato un file eseguibileword_reader.exe insieme a word_reader.dll. Quando la destinazione è Linux o macOS, viene creato word_reader file eseguibile con word_reader.dll. Per altre informazioni sui RID, vedere Catalogo RID .NET.

Importante

.NET SDK 2.1 non produce file eseguibili specifici della piattaforma quando si pubblica un'app dipendente dal framework.

Il file binario multipiattaforma dell'app può essere eseguito con il dotnet <filename.dll> comando e può essere eseguito in qualsiasi piattaforma. Se l'app usa un pacchetto NuGet con implementazioni specifiche della piattaforma, le dipendenze di tutte le piattaforme vengono copiate nella cartella di pubblicazione insieme all'app.

È possibile creare un eseguibile per una piattaforma specifica passando i -r <RID> --self-contained false parametri al dotnet publish comando . Quando il -r parametro viene omesso, viene creato un file eseguibile per la piattaforma corrente. Tutti NuGet pacchetti con dipendenze specifiche della piattaforma per la piattaforma di destinazione vengono copiati nella cartella di pubblicazione. Se non è necessario un eseguibile specifico della piattaforma, è possibile specificare nel <UseAppHost>False</UseAppHost> file di progetto. Per altre informazioni, vedere MSBuild riferimento per i progetti .NET SDK.

Vantaggi

  • Distribuzione di piccole dimensioni
    Vengono distribuite solo l'app e le relative dipendenze. Il runtime e le librerie .NET vengono installati dall'utente e tutte le app condividono il runtime.

  • Multipiattaforma
    L'app e qualsiasi . La libreria basata su NET viene eseguita in altri sistemi operativi. Non è necessario definire una piattaforma di destinazione per l'app. Per informazioni sul formato di file .NET, vedere Formato di file di assembly .NET.

  • Usa il runtime con patch più recente
    L'app usa il runtime più recente (all'interno della famiglia principale-secondaria di .NET di destinazione) installato nel sistema di destinazione. Ciò significa che l'app usa automaticamente la versione con patch più recente del runtime .NET. Questo comportamento predefinito può essere sostituito. Per altre informazioni, vedere Roll forward delle app dipendenti dal framework.

Svantaggi

  • Richiede la preinstallazione del runtime
    L'app può essere eseguita solo se la versione di .NET di destinazione dell'app è già installata nel sistema host. È possibile configurare il comportamento di roll forward per l'app in modo che richieda una versione specifica di .NET o consenta una versione più recente di .NET. Per altre informazioni, vedere Roll forward delle app dipendenti dal framework.

  • .NET può cambiare
    È possibile che il runtime e le librerie .NET siano aggiornati nel computer in cui viene eseguita l'app. In rari casi, ciò può cambiare il comportamento dell'app se si usano le librerie .NET, come la maggior parte delle app. È possibile configurare il modo in cui l'app usa le versioni più recenti di .NET. Per altre informazioni, vedere Roll forward delle app dipendenti dal framework.

Lo svantaggio seguente si applica solo a .NET Core 2.1 SDK.

  • Usare il comando dotnet per avviare l'app
    Gli utenti devono eseguire il dotnet <filename.dll> comando per avviare l'app. .NET Core 2.1 SDK non produce eseguibili specifici della piattaforma per le app pubblicate dipendenti dal framework.

Esempio

Pubblicare un'app dipendente dal framework multipiattaforma. Insieme al file DLL viene creato un file eseguibile destinato alla piattaforma corrente.

dotnet publish

Pubblicare un'app dipendente dal framework multipiattaforma. Insieme al file DLL viene creato un eseguibile Linux a 64 bit. Questo comando non funziona con .NET Core SDK 2.1.

dotnet publish -r linux-x64 --self-contained false

Pubblicare autonomamente

La pubblicazione dell'app come indipendente produce un eseguibile specifico della piattaforma. La cartella di pubblicazione di output contiene tutti i componenti dell'app, incluse le librerie .NET e il runtime di destinazione. L'app è isolata da altre app .NET e non usa un runtime condiviso installato localmente. L'utente dell'app non è necessario per scaricare e installare .NET.

Il file binario eseguibile viene prodotto per la piattaforma di destinazione specificata. Ad esempio, se si ha un'app denominata word_reader e si pubblica un file eseguibile autonomo per Windows, viene creato un fileword_reader.exefile. Pubblicazione per Linux o macOS, viene creato word_reader file di configurazione. La piattaforma e l'architettura di destinazione vengono specificate con il -r <RID> parametro per il dotnet publish comando . Per altre informazioni sui RID, vedere Catalogo RID .NET.

Se l'app ha dipendenze specifiche della piattaforma, ad esempio un pacchetto NuGet contenente dipendenze specifiche della piattaforma, queste vengono copiate nella cartella di pubblicazione insieme all'app.

Vantaggi

  • Controllare la versione di .NET
    È possibile controllare la versione di .NET distribuita con l'app.

  • Targeting specifico della piattaforma
    Poiché è necessario pubblicare l'app per ogni piattaforma, si sa dove verrà eseguita l'app. Se .NET introduce una nuova piattaforma, gli utenti non possono eseguire l'app su tale piattaforma fino a quando non si rilascia una versione che ha come destinazione tale piattaforma. È possibile testare l'app per i problemi di compatibilità prima che gli utenti eservitino l'app nella nuova piattaforma.

Svantaggi

  • Distribuzioni più grandi
    Poiché l'app include il runtime .NET e tutte le dipendenze dell'app, le dimensioni di download e lo spazio su disco rigido necessari sono maggiori di una versione dipendente dal framework .

    Suggerimento

    È possibile ridurre le dimensioni della distribuzione nei sistemi Linux di circa 28 MB usando la modalità invariante di globalizzazione .NET. In questo modo l'app deve considerare tutte le impostazioni cultura come le impostazioni cultura invarianti.

    Suggerimento

    Il trimming IL può ridurre ulteriormente le dimensioni della distribuzione.

  • Più difficile aggiornare la versione di .NET
    .NET Runtime (distribuito con l'app) può essere aggiornato solo rilasciando una nuova versione dell'app. .NET aggiornerà tuttavia le patch di sicurezza critiche in base alle esigenze per la libreria del framework nel computer in cui viene eseguita l'app. L'utente è responsabile della convalida end-to-end per questo scenario di patch di sicurezza.

Esempio

Pubblicare un'app autonomamente. Viene creato un file eseguibile a 64 bit macOS.

dotnet publish -r osx-x64

Pubblicare un'app autonomamente. Viene Windows file eseguibile a 64 bit.

dotnet publish -r win-x64

Pubblicare con immagini ReadyToRun

La pubblicazione con immagini ReadyToRun migliorerà il tempo di avvio dell'applicazione al costo di aumentare le dimensioni dell'applicazione. Per pubblicare con ReadyToRun, vedere ReadyToRun per altri dettagli.

Vantaggi

  • Tempo di avvio migliorato
    L'applicazione dedica meno tempo all'esecuzione di JIT.

Svantaggi

  • Dimensioni maggiori
    L'applicazione sarà più grande su disco.

Esempio

Pubblicare un'app autonoma e ReadyToRun. Viene creato un file eseguibile a 64 bit macOS.

dotnet publish -c Release -r osx-x64 -p:PublishReadyToRun=true

Pubblicare un'app autonoma e ReadyToRun. Viene Windows file eseguibile a 64 bit.

dotnet publish -c Release -r win-x64 -p:PublishReadyToRun=true

Vedi anche