Panoramica della pubblicazione di applicazioni .NET
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 ildotnet <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