Pubblicare app .NET con l'interfaccia della riga di comando di .NET

  • Articolo

Questo articolo illustra come pubblicare l'applicazione .NET dalla riga di comando. .NET offre tre modi per pubblicare le applicazioni. La distribuzione dipendente dal framework genera un file con estensione dll multipiattaforma che usa il runtime di .NET installato in locale. L'eseguibile dipendente dal framework genera un file eseguibile specifico della piattaforma che usa il runtime di .NET installato in locale. L'eseguibile autonomo genera un file eseguibile specifico della piattaforma e include una copia locale del runtime di .NET.

Per una panoramica di queste modalità di pubblicazione, vedere Distribuzione di applicazioni .NET.

Per un aiuto rapido sull'uso dell'interfaccia della riga di comando, la tabella seguente illustra alcuni esempi di pubblicazione di un'app. È possibile specificare il framework di destinazione con il parametro -f <TFM> o modificando il file di progetto. Per altre informazioni, vedere Nozioni di base sulla pubblicazione.

Modalità di pubblicazione Comando
Distribuzione dipendente dal framework dotnet publish -c Release -p:UseAppHost=false
File eseguibile dipendente dal framework dotnet publish -c Release -r <RID> --self-contained false
dotnet publish -c Release
Distribuzione autonoma dotnet publish -c Release -r <RID> --self-contained true

Nota

  • Il parametro -c Release non è obbligatorio. Viene fornito come promemoria per pubblicare la build di rilascio dell'app.
  • Nell’SDK .NET versione 3.1 o successiva, il file eseguibile dipendente dal framework è la modalità di pubblicazione predefinita durante l'esecuzione del comando dotnet publish di base.

Nozioni di base sulla pubblicazione

L'impostazione <TargetFramework> del file di progetto specifica il framework di destinazione predefinito quando si pubblica l'app. È possibile modificare il framework di destinazione impostando qualsiasi moniker framework di destinazione (TFM). Ad esempio, se il progetto usa <TargetFramework>net8.0</TargetFramework>, viene creato un file binario che ha come destinazione .NET 8. Il moniker framework di destinazione specificato in questa impostazione è la destinazione predefinita usata dal comando dotnet publish.

Se si vuole impostare più framework di destinazione, è possibile impostare <TargetFrameworks> su più valori di moniker framework di destinazione separati da punto e virgola. Quando si compila l'app, viene generata una build per ogni framework di destinazione. Tuttavia, quando si pubblica l'app, è necessario specificare il framework di destinazione con il comando dotnet publish -f <TFM>.

La modalità BUILD-CONFIGURATION predefinita è Debug a meno che non venga modificata con il parametro -c.

La directory di output predefinita del comando dotnet publish è ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Ad esempio, dotnet publish -c Release -f net8.0 pubblica in ./bin/Release/net8.0/publish/. Tuttavia, si può optare per un percorso di output e una struttura di cartelle semplificati per tutti gli output di compilazione. Per altre informazioni, vedere Layout di output degli artefatti.

Dipendenze native

Se l'app ha dipendenze native, è possibile che non venga eseguita in un sistema operativo diverso. Ad esempio, se l'app usa l'API Windows nativa, non verrà eseguita in macOS o Linux. Sarà necessario specificare un codice specifico della piattaforma e compilare un file eseguibile per ogni piattaforma.

Tenere presente anche che se una libreria a cui viene fatto riferimento include una dipendenza nativa, è possibile che l'app non venga eseguita in ogni piattaforma. Tuttavia, è possibile che un pacchetto NuGet cui viene fatto riferimento includa versioni specifiche della piattaforma per gestire automaticamente le dipendenze native necessarie.

Quando si distribuisce un'app con dipendenze native, potrebbe essere necessario usare l'opzione dotnet publish -r <RID> per specificare la piattaforma di destinazione per cui eseguire la pubblicazione. Per un elenco degli identificatori di runtime, vedere Catalogo RID di .NET Core.

Altre informazioni sui file binari specifici della piattaforma sono disponibili nelle sezioni File eseguibili dipendenti dal framework e Distribuzioni autonome.

Esempio di app

È possibile usare le app seguenti per visualizzare i comandi di pubblicazione. L'app viene creata eseguendo i comandi seguenti nel terminale:

mkdir apptest1
cd apptest1
dotnet new console
dotnet add package Figgle

Il file Program.cs o Program.vb generato dal modello di console deve essere modificato come segue:

using System;

namespace apptest1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"));
        }
    }
}

Module Program
    Sub Main(args As String())
        Console.WriteLine(Figgle.FiggleFonts.Standard.Render("Hello, World!"))
    End Sub
End Module

Quando si esegue l'app (dotnet run), viene visualizzato l'output seguente:

  _   _      _ _         __        __         _     _ _
 | | | | ___| | | ___    \ \      / /__  _ __| | __| | |
 | |_| |/ _ \ | |/ _ \    \ \ /\ / / _ \| '__| |/ _` | |
 |  _  |  __/ | | (_) |    \ V  V / (_) | |  | | (_| |_|
 |_| |_|\___|_|_|\___( )    \_/\_/ \___/|_|  |_|\__,_(_)
                     |/

Distribuzione dipendente dal framework

Quando si pubblica l'app come distribuzione dipendente dal framework, viene creato un file <PROJECT-NAME>.dll nella cartella ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Per eseguire l'app, passare alla cartella di output e usare il comando dotnet <PROJECT-NAME>.dll.

L'app viene configurata con una versione specifica di .NET come destinazione. Il runtime .NET di destinazione deve trovarsi in qualsiasi computer in cui viene eseguita l'app. Ad esempio, se l'app ha come destinazione .NET Core 8, ogni computer in cui viene eseguita l'app deve avere il runtime .NET Core 8 installato. Come descritto nella sezione Nozioni di base sulla pubblicazione, è possibile modificare il file di progetto per cambiare il framework di destinazione predefinito o per impostare come destinazione più framework.

La pubblicazione di una distribuzione dipendente dal framework crea un'app che esegue automaticamente il roll forward all'ultima patch di protezione .NET disponibile nel sistema che esegue l'app. Per altre informazioni sul binding di versione in fase di compilazione, vedere Selezionare la versione di .NET da usare.

Modalità di pubblicazione Comando
Distribuzione dipendente dal framework dotnet publish -c Release -p:UseAppHost=false

File eseguibile dipendente dal framework

Il file eseguibile dipendente dal framework è la modalità predefinita per il comando dotnet publish di base. Se la destinazione è il sistema operativo corrente, non è necessario specificare altri parametri.

In questa modalità viene creato un host eseguibile specifico della piattaforma per ospitare l'app multipiattaforma. Questa modalità è simile alla distribuzione dipendente dal framework che richiede un host sotto forma di comando dotnet. Il nome del file eseguibile host varia a seconda della piattaforma ed è simile a <PROJECT-FILE>.exe. È possibile eseguire questo eseguibile direttamente anziché chiamare dotnet <PROJECT-FILE>.dll per eseguire l'app.

L'app viene configurata con una versione specifica di .NET come destinazione. Il runtime .NET di destinazione deve trovarsi in qualsiasi computer in cui viene eseguita l'app. Ad esempio, se l'app ha come destinazione .NET Core 8, ogni computer in cui viene eseguita l'app deve avere il runtime .NET Core 8 installato. Come descritto nella sezione Nozioni di base sulla pubblicazione, è possibile modificare il file di progetto per cambiare il framework di destinazione predefinito o per impostare come destinazione più framework.

La pubblicazione di un eseguibile dipendente dal framework crea un'app che esegue automaticamente il roll forward all'ultima patch di protezione .NET disponibile nel sistema che esegue l'app. Per altre informazioni sul binding di versione in fase di compilazione, vedere Selezionare la versione di .NET da usare.

Modalità di pubblicazione Comando
File eseguibile dipendente dal framework dotnet publish -c Release -r <RID> --self-contained false
dotnet publish -c Release

Ogni volta che viene usata l'opzione -r, il percorso della cartella di output viene modificato in: ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/

Se si usa l'app di esempio, eseguire dotnet publish -f net6.0 -r win-x64 --self-contained false. Questo comando crea l'eseguibile seguente: ./bin/Debug/net6.0/win-x64/publish/apptest1.exe

Nota

È possibile ridurre le dimensioni totali della distribuzione abilitando la modalità invariante della globalizzazione. La modalità invariante della globalizzazione è utile per le applicazioni che non sono compatibili a livello globale e possono usare le convenzioni di formattazione, le convenzioni sulla combinazione di maiuscole e minuscole, il confronto tra stringhe e l'ordinamento delle impostazioni cultura invarianti. Per altre informazioni sulla modalità invariante della globalizzazione e su come abilitarla, vedere .NET Globalization Invariant Mode (Modalità invariante della globalizzazione di .NET).

Distribuzione autonoma

Quando si pubblica una distribuzione autonoma, l’SDK .NET crea un eseguibile specifico della piattaforma. La pubblicazione di una distribuzione guidata include tutti i file .NET necessari per eseguire l'app, ma non include le dipendenze native di .NET (ad esempio, per .NET 6 in Linux o .NET 8 in Linux). Queste dipendenze devono essere presenti nel sistema prima dell'esecuzione dell'app.

La pubblicazione di una distribuzione autonoma crea un'app che non esegue il roll forward alla versione più recente disponibile della patch di protezione di .NET. Per altre informazioni sul binding di versione in fase di compilazione, vedere Selezionare la versione di .NET da usare.

È necessario usare le opzioni seguenti con il comando dotnet publish per pubblicare una distribuzione autonoma:

  • -r <RID>

    Questa opzione usa un identificatore relativo (RID) per specificare la piattaforma di destinazione. Per un elenco degli identificatori di runtime, vedere Catalogo RID di .NET Core.

  • --self-contained true

    Questa opzione indica a .NET SDK di creare un eseguibile come scD.

Modalità di pubblicazione Comando
Distribuzione autonoma dotnet publish -c Release -r <RID> --self-contained true

Suggerimento

  • In .NET 6 e versioni successive è possibile ridurre le dimensioni totali delle app autonome compatibili pubblicandole tagliate. Ciò consente al trimmer di rimuovere parti del framework e di assembly a cui si fa riferimento che non si trovano in alcun percorso del codice o a cui potenzialmente viene fatto riferimento nella reflection di runtime. Vedere incompatibilità di taglio per determinare se il taglio ha senso per l'applicazione.
  • È possibile ridurre le dimensioni totali della distribuzione abilitando la modalità invariante della globalizzazione. La modalità invariante della globalizzazione è utile per le applicazioni che non sono compatibili a livello globale e possono usare le convenzioni di formattazione, le convenzioni sulla combinazione di maiuscole e minuscole, il confronto tra stringhe e l'ordinamento delle impostazioni cultura invarianti. Per altre informazioni sulla modalità invariante della globalizzazione e su come abilitarla, vedere .NET Core Globalization Invariant Mode (Modalità invariante della globalizzazione di .NET Core).

Vedi anche