Distribuire app .NET Core con Visual StudioDeploy .NET Core apps with Visual Studio

È possibile distribuire un'app .NET Core come distribuzione dipendente dal framework, che include i file binari dell'applicazione ma dipende dalla presenza di .NET Core nel sistema di destinazione oppure come distribuzione autonoma, che include l'applicazione e i file binari di .NET Core.You can deploy a .NET Core application either as a framework-dependent deployment, which includes your application binaries but depends on the presence of .NET Core on the target system, or as a self-contained deployment, which includes both your application and .NET Core binaries. Per una panoramica della distribuzione di applicazioni .NET Core, vedere Distribuzione di applicazioni .NET Core.For an overview of .NET Core application deployment, see .NET Core Application Deployment.

Le sezioni seguenti illustrano l'uso di Microsoft Visual Studio per creare i tipi di distribuzione seguenti:The following sections show how to use Microsoft Visual Studio to create the following kinds of deployments:

  • Distribuzione dipendente dal frameworkFramework-dependent deployment
  • Distribuzione dipendente dal framework con dipendenze di terze partiFramework-dependent deployment with third-party dependencies
  • Distribuzione autonomaSelf-contained deployment
  • Distribuzione autonoma con dipendenze di terze partiSelf-contained deployment with third-party dependencies

Per informazioni sull'uso di Visual Studio per sviluppare applicazioni .NET Core, vedere Prerequisiti per .NET Core in Windows.For information on using Visual Studio to develop .NET Core applications, see Prerequisites for .NET Core on Windows.

Distribuzione dipendente dal frameworkFramework-dependent deployment

Una distribuzione dipendente dal framework senza dipendenze di terze parti richiede la compilazione, il testing e la pubblicazione dell'app.Deploying a framework-dependent deployment with no third-party dependencies simply involves building, testing, and publishing the app. Il processo viene illustrato da un semplice esempio scritto in C#.A simple example written in C# illustrates the process.

  1. Creare il progetto.Create the project.

    Selezionare File > Nuovo > Progetto.Select File > New > Project. Nella finestra di dialogo Nuovo progetto espandere le categorie di progetti del linguaggio (C# o Visual Basic) nel riquadro dei tipi di progetti Installati, scegliere il modello .NET Core e selezionare il modello Console App (.NET Core) (App console (.NET Core)) nel riquadro centrale.In the New Project dialog, expand your language's (C# or Visual Basic) project categories in the Installed project types pane, choose .NET Core, and then select the Console App (.NET Core) template in the center pane. Immettere un nome di progetto, ad esempio "FDD", nella casella di testo Nome.Enter a project name, such as "FDD", in the Name text box. Selezionare il pulsante OK .Select the OK button.

  2. Aggiungere il codice sorgente dell'applicazione.Add the application's source code.

    Aprire il file Program.cs o Program.vb nell'editor e sostituire il codice generato automaticamente con il codice seguente.Open the Program.cs or Program.vb file in the editor and replace the auto-generated code with the following code. Questo codice richiede all'utente di immettere del testo e visualizza le singole parole immesse dall'utente.It prompts the user to enter text and displays the individual words entered by the user. Usa l'espressione regolare \w+ per separare le parole nel testo di input.It uses the regular expression \w+ to separate the words in the input text.

    using System;
    using System.Text.RegularExpressions;
    
    namespace Applications.ConsoleApps
    {
        public class ConsoleParser
        {
            public static void Main()
            {
                Console.WriteLine("Enter any text, followed by <Enter>:\n");
                String s = Console.ReadLine();
                ShowWords(s);
                Console.Write("\nPress any key to continue... ");
                Console.ReadKey();
            }
    
            private static void ShowWords(String s)
            {
                String pattern = @"\w+";
                var matches = Regex.Matches(s, pattern);
                if (matches.Count == 0)
                {
                    Console.WriteLine("\nNo words were identified in your input.");
                }
                else
                {
                    Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                    for (int ctr = 0; ctr < matches.Count; ctr++)
                    {
                        Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                    }
                }
            }
        }
    }
    
    
    Imports System.Text.RegularExpressions
    
    Namespace Applications.ConsoleApps
        Public Module ConsoleParser
            Public Sub Main()
                Console.WriteLine("Enter any text, followed by <Enter>:")
                Console.WriteLine()
                Dim s = Console.ReadLine()
                ShowWords(s)
                Console.Write($"{vbCrLf}Press any key to continue... ")
                Console.ReadKey()
            End Sub
    
            Private Sub ShowWords(s As String)
                Dim pattern = "\w+"
                Dim matches = Regex.Matches(s, pattern)
                Console.WriteLine()   
                If matches.Count = 0 Then
                    Console.WriteLine("No words were identified in your input.")
                Else
                    Console.WriteLine($"There are {matches.Count} words in your string:")
                    For ctr = 0 To matches.Count - 1
                        Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                    Next
                End If
                Console.WriteLine()
            End Sub
        End Module
    End Namespace
    
    
  3. Creare una build di debug dell'app.Create a Debug build of your app.

    Selezionare Compila > Compila soluzione.Select Build > Build Solution. È anche possibile compilare ed eseguire la build di debug dell'applicazione selezionando Esegui debug > Avvia debug.You can also compile and run the Debug build of your application by selecting Debug > Start Debugging.

  4. Distribuire l'app.Deploy your app.

    Dopo aver eseguito il debug e il test del programma, creare i file da distribuire con l'app.After you've debugged and tested the program, create the files to be deployed with your app. Per la pubblicazione da Visual Studio eseguire le operazioni seguenti:To publish from Visual Studio, do the following:

    1. Modificare la configurazione della soluzione da Debug a Release sulla barra degli strumenti, per creare una versione di rilascio dell'app (invece di una versione di debug).Change the solution configuration from Debug to Release on the toolbar to build a Release (rather than a Debug) version of your app.

    2. Fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e selezionare Pubblica.Right-click on the project (not the solution) in Solution Explorer and select Publish.

    3. Nella scheda Pubblica selezionare Pubblica.In the Publish tab, select Publish. I file che costituiscono l'applicazione vengono salvati nel file system locale.Visual Studio writes the files that comprise your application to the local file system.

    4. La scheda Pubblica ora visualizza un unico profilo FolderProfile.The Publish tab now shows a single profile, FolderProfile. Le impostazioni di configurazione del profilo vengono visualizzate nella sezione Riepilogo della scheda.The profile's configuration settings are shown in the Summary section of the tab.

    I file risultanti vengono inseriti in una directory di nome Publish in Windows e publish nei sistemi Unix, che è una sottodirectory della directory .\bin\release\netcoreapp2.1 del progetto.The resulting files are placed in a directory named Publish on Windows and publish on Unix systems that is in a subdirectory of your project's .\bin\release\netcoreapp2.1 subdirectory.

Insieme ai file dell'applicazione, il processo di pubblicazione genera un file del database di programma (con estensione pdb) che contiene le informazioni di debug relative all'app.Along with your application's files, the publishing process emits a program database (.pdb) file that contains debugging information about your app. Il file è utile soprattutto per il debug delle eccezioni.The file is useful primarily for debugging exceptions. È possibile scegliere di non includerlo nel pacchetto dei file dell'applicazione.You can choose not to package it with your application's files. È tuttavia consigliabile salvarlo perché può risultare utile per il debug della build di rilascio dell'app.You should, however, save it in the event that you want to debug the Release build of your app.

Distribuire il set completo dei file dell'applicazione con il metodo desiderato.Deploy the complete set of application files in any way you like. È ad esempio possibile inserire i file in un file zip, usare un semplice comando copy o distribuire i file con un pacchetto di installazione a scelta.For example, you can package them in a Zip file, use a simple copy command, or deploy them with any installation package of your choice. Dopo aver completato l'installazione gli utenti possono eseguire l'applicazione usando il comando dotnet e fornendo il nome file dell'applicazione, ad esempio dotnet fdd.dll.Once installed, users can then execute your application by using the dotnet command and providing the application filename, such as dotnet fdd.dll.

Oltre ai file binari dell'applicazione, il programma di installazione deve aggregare il programma di installazione framework condiviso oppure rilevarlo come prerequisito durante l'installazione dell'applicazione.In addition to the application binaries, your installer should also either bundle the shared framework installer or check for it as a prerequisite as part of the application installation. L'installazione del framework condiviso richiede l'accesso amministratore o alla radice perché è a livello di computer.Installation of the shared framework requires Administrator/root access since it is machine-wide.

Distribuzione dipendente dal framework con dipendenze di terze partiFramework-dependent deployment with third-party dependencies

In una distribuzione dipendente dal framework con una o più dipendenze di terze parti, le dipendenze devono essere disponibili per il progetto.Deploying a framework-dependent deployment with one or more third-party dependencies requires that any dependencies be available to your project. Prima della compilazione dell'app è necessario eseguire i passaggi aggiuntivi:The following additional steps are required before you can build your app:

  1. Usare Gestione pacchetti NuGet per aggiungere al progetto un riferimento a un pacchetto NuGet e per installare il pacchetto se non è già disponibile nel sistema.Use the NuGet Package Manager to add a reference to a NuGet package to your project; and if the package is not already available on your system, install it. Per aprire lo strumento per la gestione dei pacchetti, selezionare Strumenti > Gestione pacchetti NuGet > Gestisci pacchetti NuGet per la soluzione.To open the package manager, select Tools > NuGet Package Manager > Manage NuGet Packages for Solution.

  2. Verificare che Newtonsoft.Json sia installato nel sistema e, in caso contrario, installarlo.Confirm that Newtonsoft.Json is installed on your system and, if it is not, install it. La scheda Installati elenca i pacchetti NuGet installati nel sistema.The Installed tab lists NuGet packages installed on your system. Se Newtonsoft.Json non è presente nell'elenco, selezionare la scheda Sfoglia e immettere "Newtonsoft.Json" nella casella di ricerca.If Newtonsoft.Json is not listed there, select the Browse tab and enter "Newtonsoft.Json" in the search box. Selezionare Newtonsoft.Json, selezionare il progetto nel riquadro destro e quindi selezionare Installa.Select Newtonsoft.Json and, in the right pane, select your project before selecting Install.

  3. Se Newtonsoft.Json è già installato nel sistema aggiungerlo al progetto selezionando il progetto stesso nel riquadro destro della scheda Gestisci i pacchetti per la soluzione.If Newtonsoft.Json is already installed on your system, add it to your project by selecting your project in the right pane of the Manage Packages for Solution tab.

Si noti che la portabilità di una distribuzione dipendente dal framework con dipendenze di terze parti corrisponde esattamente alla portabilità delle dipendenze.Note that a framework-dependent deployment with third-party dependencies is only as portable as its third-party dependencies. Se ad esempio una libreria di terze parti supporta solo macOS, l'app non è portabile in sistemi Windows.For example, if a third-party library only supports macOS, the app isn't portable to Windows systems. Questa situazione si verifica se la dipendenza di terze parti stessa dipende da codice nativo.This happens if the third-party dependency itself depends on native code. Un buon esempio è il server Kestrel, che richiede una dipendenza nativa da libuv.A good example of this is Kestrel server, which requires a native dependency on libuv. Quando viene creata una distribuzione dipendente dal framework per un'applicazione con questo tipo di dipendenze di terze parti, l'output pubblicato contiene una cartella per ogni identificatore di runtime (RID) supportato dalla dipendenza nativa (e presente nel relativo pacchetto NuGet).When an FDD is created for an application with this kind of third-party dependency, the published output contains a folder for each Runtime Identifier (RID) that the native dependency supports (and that exists in its NuGet package).

Distribuzione autonoma senza dipendenze di terze partiSelf-contained deployment without third-party dependencies

La pubblicazione di una distribuzione autonoma senza dipendenze di terze parti comporta la creazione del progetto, la modifica del file csproj, la compilazione, il test e la pubblicazione dell'app.Deploying a self-contained deployment with no third-party dependencies involves creating the project, modifying the csproj file, building, testing, and publishing the app. Il processo viene illustrato da un semplice esempio scritto in C#.A simple example written in C# illustrates the process. Creare, codificare e testare inizialmente il progetto come nel caso di una distribuzione dipendente dal framework:You begin by creating, coding, and testing your project just as you would a framework-dependent deployment:

  1. Creare il progetto.Create the project.

    Selezionare File > Nuovo > Progetto.Select File > New > Project. Nella finestra di dialogo Nuovo progetto espandere le categorie di progetti del linguaggio (C# o Visual Basic) nel riquadro dei tipi di progetti Installati, scegliere il modello .NET Core e selezionare il modello Console App (.NET Core) (App console (.NET Core)) nel riquadro centrale.In the New Project dialog, expand your language's (C# or Visual Basic) project categories in the Installed project types pane, choose .NET Core, and then select the Console App (.NET Core) template in the center pane. Immettere un nome di progetto, ad esempio "SCD" nella casella di testo Nome, quindi selezionare il pulsante OK.Enter a project name, such as "SCD", in the Name text box, and select the OK button.

  2. Aggiungere il codice sorgente dell'applicazione.Add the application's source code.

    Aprire il file Program.cs o Program. vb nell'editor e sostituire il codice generato automaticamente con il codice seguente.Open the Program.cs or Program.vb file in your editor, and replace the auto-generated code with the following code. Questo codice richiede all'utente di immettere del testo e visualizza le singole parole immesse dall'utente.It prompts the user to enter text and displays the individual words entered by the user. Usa l'espressione regolare \w+ per separare le parole nel testo di input.It uses the regular expression \w+ to separate the words in the input text.

    using System;
    using System.Text.RegularExpressions;
    
    namespace Applications.ConsoleApps
    {
        public class ConsoleParser
        {
            public static void Main()
            {
                Console.WriteLine("Enter any text, followed by <Enter>:\n");
                String s = Console.ReadLine();
                ShowWords(s);
                Console.Write("\nPress any key to continue... ");
                Console.ReadKey();
            }
    
            private static void ShowWords(String s)
            {
                String pattern = @"\w+";
                var matches = Regex.Matches(s, pattern);
                if (matches.Count == 0)
                {
                    Console.WriteLine("\nNo words were identified in your input.");
                }
                else
                {
                    Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                    for (int ctr = 0; ctr < matches.Count; ctr++)
                    {
                        Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                    }
                }
            }
        }
    }
    
    
    Imports System.Text.RegularExpressions
    
    Namespace Applications.ConsoleApps
        Public Module ConsoleParser
            Public Sub Main()
                Console.WriteLine("Enter any text, followed by <Enter>:")
                Console.WriteLine()
                Dim s = Console.ReadLine()
                ShowWords(s)
                Console.Write($"{vbCrLf}Press any key to continue... ")
                Console.ReadKey()
            End Sub
    
            Private Sub ShowWords(s As String)
                Dim pattern = "\w+"
                Dim matches = Regex.Matches(s, pattern)
                Console.WriteLine()   
                If matches.Count = 0 Then
                    Console.WriteLine("No words were identified in your input.")
                Else
                    Console.WriteLine($"There are {matches.Count} words in your string:")
                    For ctr = 0 To matches.Count - 1
                        Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                    Next
                End If
                Console.WriteLine()
            End Sub
        End Module
    End Namespace
    
    
  3. Specificare se si intende usare la modalità invariante della globalizzazione.Determine whether you want to use globalization invariant mode.

    In particolare, se l'app è destinata a Linux, è possibile ridurre le dimensioni totali della distribuzione sfruttando la modalità invariante della globalizzazione.Particularly if your app targets Linux, you can reduce the total size of your deployment by taking advantage of 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.Globalization invariant 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 abilitare la modalità invariante fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e selezionare Modifica SCD.csproj o Modifica SCD.vbproj.To enable invariant mode, right-click on your project (not the solution) in Solution Explorer, and select Edit SCD.csproj or Edit SCD.vbproj. Aggiungere al file le seguenti righe evidenziate:Then add the following highlighted lines to the file:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.2</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <RuntimeHostConfigurationOption Include="System.Globalization.Invariant" Value="true" />
  </ItemGroup> 
</Project>
  1. Creare una build di debug dell'applicazione.Create a Debug build of your application.

    Selezionare Compila > Compila soluzione.Select Build > Build Solution. È anche possibile compilare ed eseguire la build di debug dell'applicazione selezionando Esegui debug > Avvia debug.You can also compile and run the Debug build of your application by selecting Debug > Start Debugging. Questo passaggio di debug consente di identificare i problemi dell'applicazione quando è in esecuzione sulla piattaforma host.This debugging step lets you identify problems with your application when it's running on your host platform. È tuttavia necessario testarla sulle singole piattaforme di destinazione.You still will have to test it on each of your target platforms.

    Se è stata abilitata la modalità invariante della globalizzazione, verificare soprattutto se l'assenza di dati dipendenti dalle impostazioni cultura sia adatta per l'applicazione.If you've enabled globalization invariant mode, be particularly sure to test whether the absence of culture-sensitive data is suitable for your application.

Dopo aver terminato il debug, è possibile pubblicare la distribuzione autonoma:Once you've finished debugging, you can publish your self-contained deployment:

Dopo aver eseguito il debug e il test del programma creare i file da distribuire con l'app per ogni piattaforma di destinazione.After you've debugged and tested the program, create the files to be deployed with your app for each platform that it targets.

Per pubblicare l'app da Visual Studio eseguire le operazioni seguenti:To publish your app from Visual Studio, do the following:

  1. Definire le piattaforme di destinazione per l'app.Define the platforms that your app will target.

    1. Fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e selezionare Modifica SCD.csproj.Right-click on your project (not the solution) in Solution Explorer and select Edit SCD.csproj.

    2. Creare un tag <RuntimeIdentifiers> nella sezione <PropertyGroup> del file csproj che definisce le piattaforme di destinazione dell'app e specifica l'identificatore di runtime di ogni piattaforma di destinazione.Create a <RuntimeIdentifiers> tag in the <PropertyGroup> section of your csproj file that defines the platforms your app targets, and specify the runtime identifier (RID) of each platform that you target. Si noti che è inoltre necessario aggiungere un punto e virgola per separare i RID.Note that you also need to add a semicolon to separate the RIDs. Per un elenco degli identificatori di runtime, vedere Runtime IDentifier catalog (Catalogo degli identificatori di runtime).See Runtime IDentifier catalog for a list of runtime identifiers.

    L'esempio seguente indica che l'app viene eseguita in sistemi operativi Windows 10 a 64 bit e nel sistema operativo OS X versione 10.11 a 64 bit.For example, the following example indicates that the app runs on 64-bit Windows 10 operating systems and the 64-bit OS X Version 10.11 operating system.

    <PropertyGroup>
       <RuntimeIdentifiers>win10-x64;osx.10.11-x64</RuntimeIdentifiers>
    </PropertyGroup>
    

    Si noti che l'elemento <RuntimeIdentifiers> può essere inserito in qualsiasi elemento <PropertyGroup> presente nel file csproj.Note that the <RuntimeIdentifiers> element can go into any <PropertyGroup> that you have in your csproj file. Un file di esempio csproj completo è disponibile più avanti in questa sezione.A complete sample csproj file appears later in this section.

  2. Pubblicare l'app.Publish your app.

    Dopo aver eseguito il debug e il test del programma creare i file da distribuire con l'app per ogni piattaforma di destinazione.After you've debugged and tested the program, create the files to be deployed with your app for each platform that it targets.

    Per pubblicare l'app da Visual Studio eseguire le operazioni seguenti:To publish your app from Visual Studio, do the following:

    1. Modificare la configurazione della soluzione da Debug a Release sulla barra degli strumenti, per creare una versione di rilascio dell'app (invece di una versione di debug).Change the solution configuration from Debug to Release on the toolbar to build a Release (rather than a Debug) version of your app.

    2. Fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e selezionare Pubblica.Right-click on the project (not the solution) in Solution Explorer and select Publish.

    3. Nella scheda Pubblica selezionare Pubblica.In the Publish tab, select Publish. I file che costituiscono l'applicazione vengono salvati nel file system locale.Visual Studio writes the files that comprise your application to the local file system.

    4. La scheda Pubblica ora visualizza un unico profilo FolderProfile.The Publish tab now shows a single profile, FolderProfile. Le impostazioni di configurazione del profilo vengono visualizzate nella sezione Riepilogo della scheda. Runtime di destinazione identifica il runtime pubblicato e Percorso di destinazione identifica il percorso in cui sono stati salvati i file per la distribuzione autonoma.The profile's configuration settings are shown in the Summary section of the tab. Target Runtime identifies which runtime has been published, and Target Location identifies where the files for the self-contained deployment were written.

    5. Per impostazione predefinita tutti i file pubblicati vengono salvati in una singola directory.Visual Studio by default writes all published files to a single directory. Per praticità è consigliabile creare un profilo separato per ogni runtime di destinazione e inserire i file pubblicati in una directory specifica per la piattaforma.For convenience, it's best to create separate profiles for each target runtime and to place published files in a platform-specific directory. Questo richiede la creazione di un profilo di pubblicazione separato per ogni piattaforma di destinazione.This involves creating a separate publishing profile for each target platform. A questo punto ricompilare l'applicazione per ogni piattaforma procedendo nel modo seguente:So now rebuild the application for each platform by doing the following:

      1. Selezionare Crea nuovo profilo nella finestra di dialogo Pubblica.Select Create new profile in the Publish dialog.

      2. Nella finestra di dialogo Selezionare una destinazione di pubblicazione, in Scegliere una cartella impostare il percorso su bin\Release\PublishOutput\win10-x64.In the Pick a publish target dialog, change the Choose a folder location to bin\Release\PublishOutput\win10-x64. Selezionare OK.Select OK.

      3. Selezionare il nuovo profilo (FolderProfile1) nell'elenco dei profili e assicurarsi che Runtime di destinazione sia win10-x64.Select the new profile (FolderProfile1) in the list of profiles, and make sure that the Target Runtime is win10-x64. In caso contrario, selezionare Impostazioni.If it isn't, select Settings. Nella finestra di dialogo Impostazioni profilo impostare Runtime di destinazione su win10-x64 e selezionare Salva.In the Profile Settings dialog, change the Target Runtime to win10-x64 and select Save. In alternativa selezionare Annulla.Otherwise, select Cancel.

      4. Selezionare Pubblica per pubblicare l'app per le piattaforme Windows 10 a 64 bit.Select Publish to publish your app for 64-bit Windows 10 platforms.

      5. Eseguire nuovamente la procedura per creare un profilo per la piattaforma osx.10.11-x64.Follow the previous steps again to create a profile for the osx.10.11-x64 platform. Il valore di Percorso di destinazione deve essere bin\Release\PublishOutput\osx.10.11-x64 e Runtime di destinazione deve essere osx.10.11-x64.The Target Location is bin\Release\PublishOutput\osx.10.11-x64, and the Target Runtime is osx.10.11-x64. Il nome assegnato a questo profilo in Visual Studio è FolderProfile2.The name that Visual Studio assigns to this profile is FolderProfile2.

    Si noti che ogni percorso di destinazione contiene il set completo di file (i file dell'app e tutti i file di .NET Core) necessari per l'avvio dell'app.Note that each target location contains the complete set of files (both your app files and all .NET Core files) needed to launch your app.

Insieme ai file dell'applicazione, il processo di pubblicazione genera un file del database di programma (con estensione pdb) che contiene le informazioni di debug relative all'app.Along with your application's files, the publishing process emits a program database (.pdb) file that contains debugging information about your app. Il file è utile soprattutto per il debug delle eccezioni.The file is useful primarily for debugging exceptions. È possibile scegliere di non includerlo nel pacchetto dei file dell'applicazione.You can choose not to package it with your application's files. È tuttavia consigliabile salvarlo perché può risultare utile per il debug della build di rilascio dell'app.You should, however, save it in the event that you want to debug the Release build of your app.

Distribuire i file pubblicati con il metodo desiderato.Deploy the published files in any way you like. È ad esempio possibile inserire i file in un file zip, usare un semplice comando copy o distribuire i file con un pacchetto di installazione a scelta.For example, you can package them in a Zip file, use a simple copy command, or deploy them with any installation package of your choice.

Di seguito è riportato il file csproj completo per questo progetto.The following is the complete csproj file for this project.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win10-x64;osx.10.11-x64</RuntimeIdentifiers>
  </PropertyGroup>
</Project>

Distribuzione autonoma con dipendenze di terze partiSelf-contained deployment with third-party dependencies

Una distribuzione autonoma con una o più dipendenze di terze parti comporta l'aggiunta delle dipendenze.Deploying a self-contained deployment with one or more third-party dependencies involves adding the dependencies. Prima della compilazione dell'app è necessario eseguire i passaggi aggiuntivi:The following additional steps are required before you can build your app:

  1. Usare Gestione pacchetti NuGet per aggiungere al progetto un riferimento a un pacchetto NuGet e per installare il pacchetto se non è già disponibile nel sistema.Use the NuGet Package Manager to add a reference to a NuGet package to your project; and if the package is not already available on your system, install it. Per aprire lo strumento per la gestione dei pacchetti, selezionare Strumenti > Gestione pacchetti NuGet > Gestisci pacchetti NuGet per la soluzione.To open the package manager, select Tools > NuGet Package Manager > Manage NuGet Packages for Solution.

  2. Verificare che Newtonsoft.Json sia installato nel sistema e, in caso contrario, installarlo.Confirm that Newtonsoft.Json is installed on your system and, if it is not, install it. La scheda Installati elenca i pacchetti NuGet installati nel sistema.The Installed tab lists NuGet packages installed on your system. Se Newtonsoft.Json non è presente nell'elenco, selezionare la scheda Sfoglia e immettere "Newtonsoft.Json" nella casella di ricerca.If Newtonsoft.Json is not listed there, select the Browse tab and enter "Newtonsoft.Json" in the search box. Selezionare Newtonsoft.Json, selezionare il progetto nel riquadro destro e quindi selezionare Installa.Select Newtonsoft.Json and, in the right pane, select your project before selecting Install.

  3. Se Newtonsoft.Json è già installato nel sistema aggiungerlo al progetto selezionando il progetto stesso nel riquadro destro della scheda Gestisci i pacchetti per la soluzione.If Newtonsoft.Json is already installed on your system, add it to your project by selecting your project in the right pane of the Manage Packages for Solution tab.

Di seguito è riportato il file csproj completo per questo progetto:The following is the complete csproj file for this project:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win10-x64;osx.10.11-x64</RuntimeIdentifiers>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

Quando si distribuisce l'applicazione, anche le dipendenze di terze parti usate nell'app sono contenute nei file dell'applicazione.When you deploy your application, any third-party dependencies used in your app are also contained with your application files. Non è necessario che le librerie di terze parti siano già presenti nel sistema in cui viene eseguita l'app.Third-party libraries aren't required on the system on which the app is running.

Si noti che è possibile distribuire una distribuzione autonoma solo con una libreria di terze parti alle piattaforme supportate da tale libreria.Note that you can only deploy a self-contained deployment with a third-party library to platforms supported by that library. Il caso è simile alla presenza di dipendenze di terze parti con dipendenze native in una distribuzione dipendente dal framework: le dipendenze native esistono nella piattaforma di destinazione solo se sono state installate in precedenza in tale piattaforma.This is similar to having third-party dependencies with native dependencies in your framework-dependent deployment, where the native dependencies won't exist on the target platform unless they were previously installed there.

Vedere ancheSee also