Condividi tramite

Distribuire app .NET Core con Visual Studio

È possibile distribuire un'applicazione .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 o come distribuzione autonoma, che include sia l'applicazione che i file binari .NET Core. Per una panoramica della distribuzione di applicazioni .NET Core, vedere Distribuzione di applicazioni .NET Core.

Le sezioni seguenti illustrano come usare Microsoft Visual Studio per creare i tipi di distribuzioni seguenti:

  • Distribuzione dipendente dal framework
  • Distribuzione dipendente dal framework con dipendenze di terze parti
  • Distribuzione autonoma
  • Distribuzione indipendente con dipendenze di terze parti

Per informazioni sull'uso di Visual Studio per sviluppare applicazioni .NET Core, vedere Dipendenze e requisiti di .NET Core.

Distribuzione dipendente dal framework

La distribuzione di una distribuzione dipendente dal framework senza dipendenze di terze parti comporta semplicemente la compilazione, il test e la pubblicazione dell'app. Un semplice esempio scritto in C# illustra il processo.

  1. Creare il progetto.

    Selezionare File>New (Nuovo) >Project (Progetto). Nella finestra di dialogo Nuovo progetto espandere le categorie di progetto del linguaggio (C# o Visual Basic) nel riquadro Tipi di progetto installati , scegliere .NET Core e quindi selezionare il modello App console (.NET Core) nel riquadro centrale. Immettere un nome di progetto, ad esempio "FDD", nella casella di testo Nome . Selezionare il pulsante OK.

  2. Aggiungere il codice sorgente dell'applicazione.

    Aprire il file Program.cs o Program.vb nell'editor e sostituire il codice generato automaticamente con il codice seguente. Richiede all'utente di immettere testo e di visualizzare le singole parole immesse dall'utente. Usa l'espressione \w+ regolare per separare le parole nel testo di input.

    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 ?? "You didn't enter anything.");
            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.

    Selezionare Compila>soluzione di compilazione. È anche possibile compilare ed eseguire la compilazione Debug dell'applicazione selezionando Debug>Avvia debug debug.

  4. Distribuire l'app.

    Dopo aver eseguito il debug e testato il programma, creare i file da distribuire con l'app. Per pubblicare da Visual Studio, eseguire le operazioni seguenti:

    1. Modificare la configurazione della soluzione da Debug a Rilascio sulla barra degli strumenti per compilare una versione release (anziché debug) dell'app.

    2. Fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e scegliere Pubblica.

    3. Nella scheda Pubblica selezionare Pubblica. Visual Studio scrive i file che costituiscono l'applicazione nel file system locale.

    4. La scheda Pubblica mostra ora un singolo profilo , FolderProfile. Le impostazioni di configurazione del profilo vengono visualizzate nella sezione Riepilogo della scheda .

    I file risultanti vengono inseriti in una directory denominata Publish su Windows e publish su sistemi Unix che si trova in una sottodirectory della directory \bin del progetto .\bin\release\netcoreapp2.1.

Insieme ai file dell'applicazione, il processo di pubblicazione genera un file di database di programma (con estensione pdb) che contiene informazioni di debug sull'app. Il file è utile principalmente per il debug delle eccezioni. È possibile scegliere di non crearne il pacchetto con i file dell'applicazione. È tuttavia consigliabile salvarlo nel caso in cui si voglia eseguire il debug della build release dell'app.

Distribuire il set completo di file dell'applicazione nel modo che preferisci. Ad esempio, è possibile crearne il pacchetto in un file ZIP, usare un semplice copy comando o distribuirli con qualsiasi pacchetto di installazione di propria scelta. Dopo l'installazione, gli utenti possono eseguire l'applicazione usando il dotnet comando e specificando il nome file dell'applicazione, ad esempio dotnet fdd.dll.

Oltre ai file binari dell'applicazione, il programma di installazione deve anche aggregare il programma di installazione del framework condiviso o verificarne la presenza come prerequisito come parte dell'installazione dell'applicazione. L'installazione del framework condiviso richiede accesso amministratore/root perché è a livello dell'intera macchina.

Distribuzione dipendente dal framework con dipendenze di terze parti

La distribuzione di una distribuzione dipendente dal framework con una o più dipendenze di terze parti richiede che tutte le dipendenze siano disponibili per il progetto. Prima di poter compilare l'app, sono necessari i passaggi aggiuntivi seguenti:

  1. Usare Gestione pacchetti NuGet per aggiungere un riferimento a un pacchetto NuGet al progetto; e se il pacchetto non è già disponibile nel sistema, installarlo. Per aprire il gestore dei pacchetti NuGet, selezionare Strumenti>Gestione pacchetti NuGet>Gestisci pacchetti NuGet per la soluzione.

  2. Verificare che le dipendenze di terze parti ( ad esempio , Newtonsoft.Json) siano installate nel sistema e, se non lo sono, installarle. Nella scheda Installato sono elencati i pacchetti NuGet installati nel sistema. Se Newtonsoft.Json non è elencato, selezionare la scheda Sfoglia e immettere "Newtonsoft.Json" nella casella di ricerca. Selezionare Newtonsoft.Json e, nel riquadro destro, selezionare il progetto prima di selezionare Installa.

  3. Se Newtonsoft.Json è già installato nel sistema, aggiungerlo al progetto selezionando il progetto nel riquadro destro della scheda Gestisci pacchetti per la soluzione .

Una distribuzione dipendente dal framework con dipendenze di terze parti è portabile soltanto quanto le sue dipendenze di terze parti. Ad esempio, se una libreria di terze parti supporta solo macOS, l'app non è portabile nei sistemi Windows. Ciò si verifica se la dipendenza di terze parti dipende dal codice nativo. Un buon esempio di questo è il server Kestrel, che richiede una dipendenza nativa da libuv. Quando viene creato un FDD per un'applicazione con questo tipo di dipendenza di terze parti, l'output pubblicato contiene una cartella per ogni identificatore di runtime (RID) supportato dalla dipendenza nativa (e presente nel pacchetto NuGet).

Distribuzione autonoma senza dipendenze di terze parti

La distribuzione 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. Un semplice esempio scritto in C# illustra il processo. Per iniziare, creare, scrivere codice e testare il progetto esattamente come si farebbe con una distribuzione dipendente dal framework:

  1. Creare il progetto.

    Selezionare File>New (Nuovo) >Project (Progetto). Nella finestra di dialogo Nuovo progetto espandere le categorie di progetto del linguaggio (C# o Visual Basic) nel riquadro Tipi di progetto installati , scegliere .NET Core e quindi selezionare il modello App console (.NET Core) nel riquadro centrale. Immettere un nome di progetto, ad esempio "SCD", nella casella di testo Nome e selezionare il pulsante OK .

  2. Aggiungere il codice sorgente dell'applicazione.

    Aprire il file Program.cs o Program.vb nell'editor e sostituire il codice generato automaticamente con il codice seguente. Richiede all'utente di immettere testo e di visualizzare le singole parole immesse dall'utente. Usa l'espressione \w+ regolare per separare le parole nel testo di input.

    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 ?? "You didn't enter anything.");
            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. Determinare se si desidera utilizzare la modalità invariante di globalizzazione.

    In particolare se l'app è destinata a Linux, è possibile ridurre le dimensioni totali della distribuzione sfruttando la modalità invariante di globalizzazione. La modalità di globalizzazione invariante è utile per le applicazioni che non gestiscono aspetti globali e che possono usare le convenzioni di formattazione, le convenzioni di maiuscolazione e l'ordinamento e il confronto di stringhe della cultura invariante.

    Per abilitare la modalità invariante, fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e scegliere Modifica SCD.csproj o Modifica SCD.vbproj. Aggiungere quindi le righe evidenziate seguenti al file:

    <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <RuntimeHostConfigurationOption Include="System.Globalization.Invariant" Value="true" />
  </ItemGroup> 

</Project>

  4. Creare una build di debug dell'applicazione.

    Selezionare Compila>soluzione di compilazione. È anche possibile compilare ed eseguire la compilazione Debug dell'applicazione selezionando Debug>Avvia debug debug. Questo passaggio di debug consente di identificare i problemi con l'applicazione quando è in esecuzione nella piattaforma host. Sarà comunque necessario testarlo in ognuna delle piattaforme di destinazione.

    Se hai abilitato la modalità invariante per la globalizzazione, assicurati in particolare di verificare se l'assenza di dati dipendenti dalla cultura sia adatta per la tua applicazione.

Una volta che hai finito di effettuare il debug, potrai pubblicare la distribuzione autonoma.

Dopo aver eseguito il debug e testato il programma, creare i file da distribuire con l'app per ogni piattaforma di destinazione.

Per pubblicare l'app da Visual Studio, seguire questa procedura:

  1. Definire le piattaforme di destinazione dell'app.

    1. Fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e scegliere Modifica SCD.csproj.

    2. Creare un <RuntimeIdentifiers> tag nella <PropertyGroup> sezione del file csproj che definisce le piattaforme di destinazione dell'app e specificare l'identificatore di runtime (RID) di ogni piattaforma di destinazione. È anche necessario aggiungere un punto e virgola per separare i RID. Per un elenco di identificatori di runtime, vedere Catalogo degli identificatori di runtime.

    Ad esempio, l'esempio seguente indica che l'app viene eseguita in sistemi operativi Windows a 64 bit e nel sistema operativo OS X a 64 bit.

    <PropertyGroup>
   <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
</PropertyGroup>

    L'elemento <RuntimeIdentifiers> può essere inserito in qualsiasi <PropertyGroup> presente nel tuo file csproj. Un file csproj di esempio completo viene visualizzato più avanti in questa sezione.

  2. Pubblicare l'app.

    Dopo aver eseguito il debug e testato il programma, creare i file da distribuire con l'app per ogni piattaforma di destinazione.

    Per pubblicare l'app da Visual Studio, seguire questa procedura:

    1. Modificare la configurazione della soluzione da Debug a Rilascio sulla barra degli strumenti per compilare una versione release (anziché debug) dell'app.

    2. Fare clic con il pulsante destro del mouse sul progetto (non sulla soluzione) in Esplora soluzioni e scegliere Pubblica.

    3. Nella scheda Pubblica selezionare Pubblica. Visual Studio scrive i file che costituiscono l'applicazione nel file system locale.

    4. La scheda Pubblica mostra ora un singolo profilo , FolderProfile. Le impostazioni di configurazione del profilo vengono visualizzate nella sezione Riepilogo della scheda. Runtime di destinazione identifica il runtime pubblicato e Destinazione identifica dove sono stati scritti i file per la distribuzione autonoma.

    5. Per impostazione predefinita, Visual Studio scrive tutti i file pubblicati in una singola directory. Per praticità, è consigliabile creare profili separati per ogni runtime di destinazione e inserire i file pubblicati in una directory specifica della piattaforma. Ciò comporta la creazione di un profilo di pubblicazione separato per ogni piattaforma di destinazione. A questo punto, ricompilare l'applicazione per ogni piattaforma eseguendo le operazioni seguenti:

      1. Selezionare Crea nuovo profilo nella finestra di dialogo Pubblica .

      2. Nella finestra di dialogo Selezionare una destinazione di pubblicazione modificare il percorso Scegliere una cartella in bin\Release\PublishOutput\win-x64. Seleziona OK.

      3. Selezionare il nuovo profilo (FolderProfile1) nell'elenco dei profili e assicurarsi che il Target Runtime sia win-x64. In caso contrario, selezionare Impostazioni. Nella finestra di dialogo Impostazioni profilo modificare il runtime di destinazione in win-x64 e selezionare Salva. In caso contrario, selezionare Annulla.

      4. Selezionare Pubblica per pubblicare l'app per piattaforme Windows 10 a 64 bit.

      5. Seguire di nuovo i passaggi precedenti per creare un profilo per la osx-x64 piattaforma. Il percorso di destinazione è bin\Release\PublishOutput\osx-x64 e il runtime di destinazione è osx-x64. Il nome assegnato da Visual Studio a questo profilo è FolderProfile2.

    Ogni percorso di destinazione contiene il set completo di file (sia i file dell'app che tutti i file .NET Core) necessari per avviare l'app.

Insieme ai file dell'applicazione, il processo di pubblicazione genera un file di database di programma (con estensione pdb) che contiene informazioni di debug sull'app. Il file è utile principalmente per il debug delle eccezioni. È possibile scegliere di non crearne il pacchetto con i file dell'applicazione. È tuttavia consigliabile salvarlo nel caso in cui si voglia eseguire il debug della build release dell'app.

Distribuisci i file pubblicati nel modo che preferisci. Ad esempio, è possibile crearne il pacchetto in un file ZIP, usare un semplice copy comando o distribuirli con qualsiasi pacchetto di installazione di propria scelta.

Di seguito è riportato il file csproj completo per questo progetto.

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

Distribuzione indipendente con dipendenze di terze parti

Distribuire una distribuzione autonoma con una o più dipendenze di terze parti comporta l'aggiunta di tali dipendenze. Prima di poter compilare l'app, sono necessari i passaggi aggiuntivi seguenti:

  1. Usare Gestione pacchetti NuGet per aggiungere un riferimento a un pacchetto NuGet al progetto; e se il pacchetto non è già disponibile nel sistema, installarlo. Per aprire il gestore dei pacchetti NuGet, selezionare Strumenti>Gestione pacchetti NuGet>Gestisci pacchetti NuGet per la soluzione.

  2. Verificare che le dipendenze di terze parti ( ad esempio , Newtonsoft.Json) siano installate nel sistema e, se non lo sono, installarle. Nella scheda Installato sono elencati i pacchetti NuGet installati nel sistema. Se Newtonsoft.Json non è elencato, selezionare la scheda Sfoglia e immettere "Newtonsoft.Json" nella casella di ricerca. Selezionare Newtonsoft.Json e, nel riquadro destro, selezionare il progetto prima di selezionare Installa.

  3. Se Newtonsoft.Json è già installato nel sistema, aggiungerlo al progetto selezionando il progetto nel riquadro destro della scheda Gestisci pacchetti per la soluzione .

Di seguito è riportato il file csproj completo per questo progetto:

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

Quando si distribuisce l'applicazione, tutte le dipendenze di terze parti usate nell'app sono contenute anche con i file dell'applicazione. Le librerie di terze parti non sono necessarie nel sistema in cui è in esecuzione l'app.

È possibile distribuire una distribuzione autonoma solo con una libreria di terze parti nelle piattaforme supportate da tale libreria. Questa operazione è simile alla presenza di dipendenze di terze parti con dipendenze native nella distribuzione dipendente dal framework, in cui le dipendenze native non esistono nella piattaforma di destinazione a meno che non siano state installate in precedenza.

Vedere anche