Condividi tramite

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.

Cerchi un aiuto rapido per usare l'interfaccia della riga di comando (CLI)? 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 Rilascio della tua 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 in qualsiasi moniker framework di destinazione (TFM) valido. Ad esempio, se il progetto usa <TargetFramework>net9.0</TargetFramework>, viene creato un file binario destinato a .NET 9. Il TFM specificato in questa impostazione è il target predefinito usato dal comando dotnet publish.

Se si desidera mirare a più di un framework, è possibile impostare l'impostazione <TargetFrameworks> su più valori TFM, 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 è Release a meno che non venga modificata con il -c parametro .

La directory di output predefinita del comando dotnet publish è ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. Ad esempio, dotnet publish -c Release -f net9.0 pubblica in ./bin/Release/net9.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 pubblichi l'app come FDD, 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 è destinata a .NET 9, qualsiasi computer in cui viene eseguita l'app deve avere installato il runtime .NET 9. 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 FDD crea un'app che si aggiorna automaticamente all'ultima patch di sicurezza .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 (FDE) è la modalità predefinita per il comando di base dotnet publish. 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 all'FDD, poiché l'FDD richiede un host sotto forma del 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é utilizzare dotnet <PROJECT-FILE>.dll, che è comunque un modo accettabile 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 è destinata a .NET 9, qualsiasi computer in cui viene eseguita l'app deve avere installato il runtime .NET 9. 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 aggiorna automaticamente all'ultima patch di protezione .NET disponibile sul sistema in cui viene eseguita 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 net9.0 -r win-x64 --self-contained false. Questo comando crea l'eseguibile seguente: ./bin/Debug/net9.0/win-x64/publish/apptest1.exe

Nota

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

Configurare il comportamento di ricerca dell'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 completamente autonoma (SCD), l’SDK di .NET crea un eseguibile per una piattaforma specifica. La pubblicazione di una distribuzione autonoma include tutti i file .NET necessari per eseguire l'app, ma non include le dipendenze native di .NET (ad esempio, per .NET 8 su Linux). Queste dipendenze devono essere presenti nel sistema prima dell'esecuzione dell'app.

La pubblicazione di uno SCD crea un'app che non esegue l'aggiornamento automatico alla versione più recente disponibile della patch di sicurezza .NET. Per altre informazioni sul binding di versione in fase di compilazione, vedere Selezionare la versione di .NET da usare.

È necessario usare i seguenti switch con il comando dotnet publish per pubblicare una SCD:

  • -r <RID>

    Questo interruttore usa un identificatore (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.

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 degli assembly a cui si fa riferimento che non sono inclusi in alcun percorso del codice o che potrebbero essere potenzialmente richiamati nella reflection di runtime. Consultare incompatibilità di ottimizzazione per determinare se l'ottimizzazione è appropriata per l'applicazione.
  • È possibile ridurre le dimensioni totali della distribuzione abilitando la modalità invariante della globalizzazione. Questa modalità è utile per le applicazioni che non sono compatibili a livello globale e possono utilizzare le convenzioni di formattazione, le convenzioni di maiuscole e minuscole, il confronto tra stringhe e l'ordinamento della cultura invariante. 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