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

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.

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, è possibile acconsentire esplicitamente a un percorso di output e a 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.

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.

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

Configurare il comportamento di ricerca di installazione di .NET

In .NET 9 e versioni successive è possibile configurare i percorsi di ricerca di installazione .NET del file eseguibile pubblicato tramite le proprietà AppHostDotNetSearch e AppHostRelativeDotNet.

AppHostDotNetSearch consente di specificare uno o più percorsi in cui il file eseguibile cercherà un'installazione .NET:

• AppLocal: cartella del file eseguibile dell'app
• AppRelative: percorso relativo al file eseguibile dell'app
• EnvironmentVariables: valore delle variabili di ambiente DOTNET_ROOT[_<arch>]
• Global: posizioni di installazione globale registrate e predefinite

AppHostRelativeDotNet specifica il percorso relativo al file eseguibile che verrà cercato quando AppHostDotNetSearch contiene AppRelative.

Per altre informazioni, vedere AppHostDotNetSearch, AppHostRelativeDotNet e opzioni di posizioni di installazione in apphost.

Distribuzione autonoma

Quando si pubblica una distribuzione autonoma, l’SDK .NET crea un eseguibile specifico della piattaforma. La pubblicazione di una SCD 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 all’SDK .NET di creare un eseguibile come distribuzione autonoma.

Vedi anche

• Cenni preliminari sulla distribuzione di applicazioni .NET
• Catalogo RID (Runtime Identifier) .NET