Pubblicare le app .NET Core con l'interfaccia della riga di comandoPublish .NET Core apps with the CLI

Questo articolo illustra come pubblicare l'applicazione .NET Core dalla riga di comando.This article demonstrates how you can publish your .NET Core application from the command line. .NET Core offre tre modi per pubblicare le applicazioni..NET Core provides three ways to publish your applications. La distribuzione dipendente dal framework genera un file con estensione dll multipiattaforma che usa il runtime di .NET Core installato in locale.Framework-dependent deployment produces a cross-platform .dll file that uses the locally installed .NET Core runtime. L'eseguibile dipendente dal framework genera un file eseguibile specifico della piattaforma che usa il runtime di .NET Core installato in locale.Framework-dependent executable produces a platform-specific executable that uses the locally installed .NET Core runtime. L'eseguibile autonomo genera un file eseguibile specifico della piattaforma e include una copia locale del runtime di .NET Core.Self-contained executable produces a platform-specific executable and includes a local copy of the .NET Core runtime.

Per una panoramica di queste modalità di pubblicazione, vedere Distribuzione di applicazioni .NET Core.For an overview of these publishing modes, see .NET Core Application Deployment.

Per un aiuto rapido sull'uso dell'interfaccia della riga di comando,Looking for some quick help on using the CLI? la tabella seguente illustra alcuni esempi di pubblicazione di un'app.The following table shows some examples of how to publish your app. È possibile specificare il framework di destinazione con il parametro -f <TFM> o modificando il file di progetto.You can specify the target framework with the -f <TFM> parameter or by editing the project file. Per altre informazioni, vedere Nozioni di base sulla pubblicazione.For more information, see Publishing basics.

Modalità di pubblicazionePublish Mode Versione SDKSDK Version ComandoCommand
Distribuzione dipendente dal frameworkFramework-dependent deployment 2.x2.x dotnet publish -c Release
File eseguibile dipendente dal frameworkFramework-dependent executable 2.22.2 dotnet publish -c Release -r <RID> --self-contained false
3.03.0 dotnet publish -c Release -r <RID> --self-contained false
3.0*3.0* dotnet publish -c Release
Distribuzione autonomaSelf-contained deployment 2.12.1 dotnet publish -c Release -r <RID> --self-contained true
2.22.2 dotnet publish -c Release -r <RID> --self-contained true
3.03.0 dotnet publish -c Release -r <RID> --self-contained true

* Quando si usa l'SDK versione 3.0, il file eseguibile dipendente dal framework è la modalità di pubblicazione predefinita durante l'esecuzione del comando dotnet publish di base.* When using SDK version 3.0, framework-dependent executable is the default publishing mode when running the basic dotnet publish command. Questo vale solo quando il progetto è destinato a .NET Core 2.1 o .NET Core 3.0.This only applies when the project targets either .NET Core 2.1 or .NET Core 3.0.

Nozioni di base sulla pubblicazionePublishing basics

L'impostazione <TargetFramework> del file di progetto specifica il framework di destinazione predefinito quando si pubblica l'app.The <TargetFramework> setting of the project file specifies the default target framework when you publish your app. È possibile modificare il framework di destinazione impostando qualsiasi moniker framework di destinazione (TFM).You can change the target framework to any valid Target Framework Moniker (TFM). Ad esempio, se il progetto usa <TargetFramework>netcoreapp2.2</TargetFramework>, viene creato un file binario che ha come destinazione .NET Core 2.2.For example, if your project uses <TargetFramework>netcoreapp2.2</TargetFramework>, a binary that targets .NET Core 2.2 is created. Il moniker framework di destinazione specificato in questa impostazione è la destinazione predefinita usata dal comando dotnet publish.The TFM specified in this setting is the default target used by the dotnet publish command.

Se si vuole impostare più framework di destinazione, è possibile impostare <TargetFrameworks> su più valori di moniker framework di destinazione separati da punto e virgola.If you want to target more than one framework, you can set the <TargetFrameworks> setting to more than one TFM value separated by a semicolon. È possibile pubblicare uno dei framework con il comando dotnet publish -f <TFM>.You can publish one of the frameworks with the dotnet publish -f <TFM> command. Ad esempio, se è stato specificato <TargetFrameworks>netcoreapp2.1;netcoreapp2.2</TargetFrameworks> e si esegue dotnet publish -f netcoreapp2.1, viene creato un file binario che ha come destinazione .NET Core 2.1.For example, if you have <TargetFrameworks>netcoreapp2.1;netcoreapp2.2</TargetFrameworks> and run dotnet publish -f netcoreapp2.1, a binary that targets .NET Core 2.1 is created.

Se non è stata impostata diversamente, la directory di output del comando dotnet publish è ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/.Unless otherwise set, the output directory of the dotnet publish command is ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/. La modalità BUILD-CONFIGURATION predefinita è Debug a meno che non venga modificata con il parametro -c.The default BUILD-CONFIGURATION mode is Debug unless changed with the -c parameter. Ad esempio, dotnet publish -c Release -f netcoreapp2.1 pubblica in myfolder/bin/Release/netcoreapp2.1/publish/.For example, dotnet publish -c Release -f netcoreapp2.1 publishes to myfolder/bin/Release/netcoreapp2.1/publish/.

Se si usa .NET Core SDK 3.0, la modalità di pubblicazione predefinita per le app che hanno come destinazione .NET Core versione 2.1, 2.2 o 3.0 è un file eseguibile dipendente dal framework.If you use .NET Core SDK 3.0, the default publish mode for apps that target .NET Core versions 2.1, 2.2, or 3.0 is framework-dependent executable.

Se si usa .NET Core SDK 2.1, la modalità di pubblicazione predefinita per le app che hanno come destinazione .NET Core versione 2.1 o 2.2 è una distribuzione dipendente dal framework.If you use .NET Core SDK 2.1, the default publish mode for apps that target .NET Core versions 2.1, 2.2 is framework-dependent deployment.

Dipendenze nativeNative dependencies

Se l'app ha dipendenze native, è possibile che non venga eseguita in un sistema operativo diverso.If your app has native dependencies, it may not run on a different operating system. Ad esempio, se l'app usa l'API Windows nativa, non verrà eseguita in macOS o Linux.For example, if your app uses the native Windows API, it won't run on macOS or Linux. Sarà necessario specificare un codice specifico della piattaforma e compilare un file eseguibile per ogni piattaforma.You would need to provide platform-specific code and compile an executable for each platform.

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.Consider also, if a library you referenced has a native dependency, your app may not run on every platform. Tuttavia, è possibile che un pacchetto NuGet cui viene fatto riferimento includa versioni specifiche della piattaforma per gestire automaticamente le dipendenze native necessarie.However, it's possible a NuGet package you're referencing has included platform-specific versions to handle the required native dependencies for you.

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.When distributing an app with native dependencies, you may need to use the dotnet publish -r <RID> switch to specify the target platform you want to publish for. Per un elenco degli identificatori di runtime, vedere Catalogo RID di .NET Core.For a list of runtime identifiers, see Runtime Identifier (RID) catalog.

Altre informazioni sui file binari specifici della piattaforma sono disponibili nelle sezioni File eseguibili dipendenti dal framework e Distribuzioni autonome.More information about platform-specific binaries is covered in the Framework-dependent executable and Self-contained deployment sections.

App di esempioSample app

È possibile usare entrambe le app seguenti per visualizzare i comandi di pubblicazione.You can use either the following app to explore the publishing commands. L'app viene creata eseguendo i comandi seguenti nel terminale:The app is created by running the following commands in your terminal:

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:The Program.cs or Program.vb file that is generated by the console template needs to be changed to the following:

using System;

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

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:When you run the app (dotnet run), the following output is displayed:

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

Distribuzione dipendente dal frameworkFramework-dependent deployment

Per l'interfaccia della riga di comando di .NET Core SDK 2.x, la distribuzione dipendente dal framework è la modalità predefinita per il comando dotnet publish di base.For the .NET Core SDK 2.x CLI, framework-dependent deployment (FDD) is the default mode for the basic dotnet publish command.

Quando si pubblica l'app come distribuzione dipendente dal framework, viene creato un file <PROJECT-NAME>.dll nella cartella ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/.When you publish your app as an FDD, a <PROJECT-NAME>.dll file is created in the ./bin/<BUILD-CONFIGURATION>/<TFM>/publish/ folder. Per eseguire l'app, passare alla cartella di output e usare il comando dotnet <PROJECT-NAME>.dll.To run your app, navigate to the output folder and use the dotnet <PROJECT-NAME>.dll command.

L'app viene configurata con una versione specifica di .NET Core come destinazione.Your app is configured to target a specific version of .NET Core. Il runtime .NET Core di destinazione deve trovarsi nel computer in cui si vuole eseguire l'app.That targeted .NET Core runtime is required to be on the machine where you want to run your app. Ad esempio, se l'app ha come destinazione .NET Core 2.2, ogni computer in cui viene eseguita l'app deve avere il runtime .NET Core 2.2 installato.For example, if your app targets .NET Core 2.2, any machine that your app runs on must have the .NET Core 2.2 runtime installed. 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.As stated in the Publishing basics section, you can edit your project file to change the default target framework or to target more than one framework.

La pubblicazione di una distribuzione dipendente dal framework crea un'app che esegue automaticamente il roll forward all'ultima patch di protezione .NET Core disponibile nel sistema che esegue l'app.Publishing an FDD creates an app that automatically rolls-forward to the latest .NET Core security patch available on the system that runs the app. Per altre informazioni sul binding di versione in fase di compilazione, vedere Selezionare la versione di .NET Core da usare.For more information on version binding at compile time, see Select the .NET Core version to use.

File eseguibile dipendente dal frameworkFramework-dependent executable

Per l'interfaccia della riga di comando di .NET Core SDK 3.x, il file eseguibile dipendente dal framework è la modalità predefinita per il comando dotnet publish di base.For the .NET Core SDK 3.x CLI, framework-dependent executable (FDE) the default mode for the basic dotnet publish command. Se la destinazione è il sistema operativo corrente, non è necessario specificare altri parametri.You don't need to specify any other parameters as long as you want to target the current operating system.

In questa modalità viene creato un host eseguibile specifico della piattaforma per ospitare l'app multipiattaforma.In this mode, a platform-specific executable host is created to host your cross-platform app. Questa modalità è simile alla distribuzione dipendente dal framework che richiede un host sotto forma di comando dotnet.This mode is similar to FDD as FDD requires a host in the form of the dotnet command. Il nome del file eseguibile host varia a seconda della piattaforma ed è simile a <PROJECT-FILE>.exe.The host executable filename varies per platform, and is named something similar to <PROJECT-FILE>.exe. È possibile eseguire questo eseguibile direttamente anziché chiamare dotnet <PROJECT-FILE>.dll per eseguire l'app.You can run this executable directly instead of calling dotnet <PROJECT-FILE>.dll which is still an acceptable way to run the app.

L'app viene configurata con una versione specifica di .NET Core come destinazione.Your app is configured to target a specific version of .NET Core. Il runtime .NET Core di destinazione deve trovarsi nel computer in cui si vuole eseguire l'app.That targeted .NET Core runtime is required to be on the machine where you want to run your app. Ad esempio, se l'app ha come destinazione .NET Core 2.2, ogni computer in cui viene eseguita l'app deve avere il runtime .NET Core 2.2 installato.For example, if your app targets .NET Core 2.2, any machine that your app runs on must have the .NET Core 2.2 runtime installed. 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.As stated in the Publishing basics section, you can edit your project file to change the default target framework or to target more than one framework.

La pubblicazione di un eseguibile dipendente dal framework crea un'app che esegue automaticamente il roll forward all'ultima patch di protezione .NET Core disponibile nel sistema che esegue l'app.Publishing an FDE creates an app that automatically rolls-forward to the latest .NET Core security patch available on the system that runs the app. Per altre informazioni sul binding di versione in fase di compilazione, vedere Selezionare la versione di .NET Core da usare.For more information on version binding at compile time, see Select the .NET Core version to use.

Per pubblicare un eseguibile dipendente dal framework è necessario usare le opzioni seguenti con il comando dotnet publish (ad eccezione di .NET Core 3.x con la piattaforma corrente come destinazione):You must (except for .NET Core 3.x when you target the current platform) use the following switches with the dotnet publish command to publish an FDE:

  • -r <RID> Questa opzione usa un identificatore relativo (RID) per specificare la piattaforma di destinazione.This switch uses an identifier (RID) to specify the target platform. Per un elenco degli identificatori di runtime, vedere Catalogo RID di .NET Core.For a list of runtime identifiers, see Runtime Identifier (RID) catalog.

  • --self-contained false Questa opzione indica a .NET Core SDK di creare un eseguibile come eseguibile dipendente dal framework.--self-contained false This switch tells the .NET Core SDK to create an executable as an FDE.

Ogni volta che viene usata l'opzione -r, il percorso della cartella di output viene modificato in:Whenever you use the -r switch, the output folder path changes to: ./bin/<BUILD-CONFIGURATION>/<TFM>/<RID>/publish/

Se si usa l'app di esempio, eseguire dotnet publish -f netcoreapp2.2 -r win10-x64 --self-contained false.If you use the example app, run dotnet publish -f netcoreapp2.2 -r win10-x64 --self-contained false. Questo comando crea l'eseguibile seguente:This command creates the following executable: ./bin/Debug/netcoreapp2.2/win10-x64/publish/apptest1.exe

Nota

È possibile ridurre le dimensioni totali della distribuzione abilitando la modalità invariante della globalizzazione.You can reduce the total size of your deployment by enabling globalization invariant mode. 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.This mode is useful for applications that are not globally aware and that can use the formatting conventions, casing conventions, and string comparison and sort order of the invariant culture. 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)For more information about globalization invariant mode and how to enable it, see .NET Core Globalization Invariant Mode

Distribuzione autonomaSelf-contained deployment

Quando si pubblica una distribuzione autonoma, .NET Core SDK crea un eseguibile specifico della piattaforma.When you publish a self-contained deployment (SCD), the .NET Core SDK creates a platform-specific executable. La pubblicazione di una distribuzione autonoma include tutti i file .NET Core necessari per eseguire l'app ma non include le dipendenze native di .NET Core.Publishing an SCD includes all required .NET Core files to run your app but it doesn't include the native dependencies of .NET Core. Queste dipendenze devono essere presenti nel sistema prima dell'esecuzione dell'app.These dependencies must be present on the system before the app runs.

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 Core.Publishing an SCD creates an app that doesn't roll-forward to the latest available .NET Core security patch. Per altre informazioni sul binding di versione in fase di compilazione, vedere Selezionare la versione di .NET Core da usare.For more information on version binding at compile time, see Select the .NET Core version to use.

È necessario usare le opzioni seguenti con il comando dotnet publish per pubblicare una distribuzione autonoma:You must use the following switches with the dotnet publish command to publish an SCD:

  • -r <RID> Questa opzione usa un identificatore relativo (RID) per specificare la piattaforma di destinazione.This switch uses an identifier (RID) to specify the target platform. Per un elenco degli identificatori di runtime, vedere Catalogo RID di .NET Core.For a list of runtime identifiers, see Runtime Identifier (RID) catalog.

  • --self-contained true Questa opzione indica a .NET Core SDK di creare un eseguibile come distribuzione autonoma.--self-contained true This switch tells the .NET Core SDK to create an executable as an SCD.

Nota

È possibile ridurre le dimensioni totali della distribuzione abilitando la modalità invariante della globalizzazione.You can reduce the total size of your deployment by enabling globalization invariant mode. 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.This mode is useful for applications that are not globally aware and that can use the formatting conventions, casing conventions, and string comparison and sort order of the invariant culture. 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)For more information about globalization invariant mode and how to enable it, see .NET Core Globalization Invariant Mode

Vedere ancheSee also