Udostępnij za pośrednictwem

Wdrażanie aplikacji platformy .NET Core za pomocą programu Visual Studio

Aplikację platformy .NET Core można wdrożyć jako wdrożenie zależne od platformy, które obejmuje pliki binarne aplikacji, ale zależy od obecności platformy .NET Core w systemie docelowym lub jako samodzielnego wdrożenia obejmującego zarówno aplikację, jak i pliki binarne platformy .NET Core. Aby zapoznać się z omówieniem wdrażania aplikacji platformy .NET Core, zobacz Wdrażanie aplikacji platformy .NET Core.

W poniższych sekcjach pokazano, jak za pomocą programu Microsoft Visual Studio utworzyć następujące rodzaje wdrożeń:

  • Wdrożenie zależne od struktury
  • Wdrożenie zależne od struktury z zależnościami innych firm
  • Niezależne wdrożenie
  • Samodzielne wdrażanie z zależnościami od firm trzecich

Aby uzyskać informacje na temat tworzenia aplikacji platformy .NET Core przy użyciu programu Visual Studio, zobacz .NET Core dependencies and requirements (Zależności i wymagania dotyczące platformy .NET Core).

Wdrożenie zależne od struktury

Wdrożenie zależne od platformy bez zewnętrznych zależności sprowadza się do stworzenia, przetestowania i opublikowania aplikacji. Prosty przykład napisany w języku C# ilustruje proces.

  1. Utwórz projekt.

    Wybierz Plik>Nowy>Projekt. W oknie dialogowym Nowy projekt rozwiń kategorie projektów języka (C# lub Visual Basic) w okienku Zainstalowane typy projektów, wybierz pozycję .NET Core, a następnie wybierz szablon Aplikacja konsolowa (.NET Core) w okienku środkowym. Wprowadź nazwę projektu, taką jak "FDD", w polu tekstowym Nazwa . Wybierz przycisk OK.

  2. Dodaj kod źródłowy aplikacji.

    Otwórz plik Program.cs lub Program.vb w edytorze i zastąp wygenerowany automatycznie kod poniższym kodem. Monituje użytkownika o wprowadzenie tekstu i wyświetla poszczególne wyrazy wprowadzone przez użytkownika. Używa wyrażenia regularnego \w+ , aby oddzielić wyrazy w tekście wejściowym.

    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. Utwórz kompilację debug aplikacji.

    Wybierz pozycję Kompiluj rozwiązanie kompilacji>. Możesz również skompilować i uruchomić kompilację debugowania aplikacji, wybierając pozycję Debuguj>rozpocznij debugowanie.

  4. Wdróż aplikację.

    Po debugowania i przetestowaniu programu utwórz pliki, które mają zostać wdrożone w aplikacji. Aby opublikować w programie Visual Studio, wykonaj następujące czynności:

    1. Zmień konfigurację rozwiązania z Debuguj na Wydanie na pasku narzędzi, aby utworzyć wersję wydania (a nie debugowania) aplikacji.

    2. Kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksploratorze rozwiązań i wybierz pozycję Publikuj.

    3. Na karcie Publikowanie wybierz pozycję Publikuj. Program Visual Studio zapisuje pliki składające się na aplikację do lokalnego systemu plików.

    4. Na karcie Publikowanie jest teraz wyświetlany pojedynczy profil FolderProfile. Ustawienia konfiguracji profilu są wyświetlane w sekcji Podsumowanie karty.

    Pliki wynikowe są umieszczane w katalogu o nazwie Publish w systemach Windows i publish Unix, który znajduje się w podkatalogu projektu .\bin\release\netcoreapp2.1.

Wraz z plikami aplikacji proces publikowania emituje plik bazy danych programu (.pdb), który zawiera informacje o debugowaniu aplikacji. Plik jest przydatny głównie w przypadku debugowania wyjątków. Możesz zdecydować się nie pakować go z plikami aplikacji. Należy jednak zapisać go na wypadek, gdybyś chciał debugować kompilację w wersji Release swojej aplikacji.

Wdróż pełny zestaw plików aplikacji w dowolny sposób. Możesz na przykład spakować je w pliku Zip, użyć prostego copy polecenia lub wdrożyć je przy użyciu dowolnego wybranego pakietu instalacyjnego. Po zainstalowaniu użytkownicy mogą następnie uruchomić aplikację za pomocą polecenia dotnet i podając nazwę pliku aplikacji, taką jak dotnet fdd.dll.

Oprócz plików binarnych aplikacji instalator powinien również utworzyć pakiet instalatora platformy udostępnionej lub sprawdzić go jako wymaganie wstępne w ramach instalacji aplikacji. Instalacja platformy udostępnionej wymaga dostępu administratora/głównego, ponieważ jest ona dostępna dla całej maszyny.

Wdrożenie zależne od struktury z zależnościami innych firm

Wdrożenie zależne od frameworku z co najmniej jedną zależnością innej firmy wymaga, aby wszystkie zależności były dostępne dla projektu. Przed utworzeniem aplikacji wymagane są następujące dodatkowe kroki:

  1. Użyj Menedżera pakietów NuGet , aby dodać odwołanie do pakietu NuGet do projektu; a jeśli pakiet nie jest jeszcze dostępny w systemie, zainstaluj go. Aby otworzyć menedżera pakietów, wybierz pozycję Narzędzia> Menedżer >Zarządzaj pakietami NuGet dla rozwiązania.

  2. Upewnij się, że zależności innych firm (na przykład Newtonsoft.Json) są zainstalowane w systemie i, jeśli nie, zainstaluj je. Karta Zainstalowane zawiera listę pakietów NuGet zainstalowanych w systemie. Jeśli Newtonsoft.Json nie jest wymieniony na liście, wybierz kartę Przeglądaj i wpisz "Newtonsoft.Json" w polu wyszukiwania. Wybierz pozycję Newtonsoft.Json i w okienku po prawej stronie wybierz projekt przed wybraniem pozycji Zainstaluj.

  3. Jeśli Newtonsoft.Json jest już zainstalowany w Twoim systemie, dodaj go do projektu, wybierając go w okienku po prawej stronie w karcie Zarządzanie pakietami dla rozwiązania.

Wdrożenie zależne od platformy z zależnościami innych firm ma taką samą przenośność jak jego zależności innych firm. Jeśli na przykład biblioteka innej firmy obsługuje tylko system macOS, aplikacja nie jest przenośna do systemów Windows. Dzieje się tak, jeśli zależność osoby trzeciej zależy od kodu natywnego. Dobrym przykładem jest serwer Kestrel, który wymaga natywnej zależności od biblioteki libuv. Gdy tworzony jest FDD (Framework-Dependent Deployment) dla aplikacji z tego rodzaju zależnością od innych firm, opublikowane dane wyjściowe zawierają folder dla każdego identyfikatora środowiska uruchomieniowego (RID), który natywna zależność obsługuje (i który istnieje w jej pakiecie NuGet).

Samodzielne wdrażanie bez zależności innych firm

Wdrożenie samodzielnego wdrożenia bez zależności innych firm obejmuje utworzenie projektu, zmodyfikowanie pliku csproj , kompilowanie, testowanie i publikowanie aplikacji. Prosty przykład napisany w języku C# ilustruje proces. Zacznij od utworzenia, kodowania i testowania projektu tak samo jak wdrożenie zależne od platformy:

  1. Utwórz projekt.

    Wybierz Plik>Nowy>Projekt. W oknie dialogowym Nowy projekt rozwiń kategorie projektów języka (C# lub Visual Basic) w okienku Zainstalowane typy projektów, wybierz pozycję .NET Core, a następnie wybierz szablon Aplikacja konsolowa (.NET Core) w okienku środkowym. Wprowadź nazwę projektu, taką jak "SCD", w polu tekstowym Nazwa i wybierz przycisk OK .

  2. Dodaj kod źródłowy aplikacji.

    Otwórz plik Program.cs lub Program.vb w edytorze i zastąp wygenerowany automatycznie kod poniższym kodem. Monituje użytkownika o wprowadzenie tekstu i wyświetla poszczególne wyrazy wprowadzone przez użytkownika. Używa wyrażenia regularnego \w+ , aby oddzielić wyrazy w tekście wejściowym.

    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. Określ, czy chcesz używać niezmiennego trybu globalizacji.

    Szczególnie jeśli aplikacja jest przeznaczona dla systemu Linux, możesz zmniejszyć całkowity rozmiar wdrożenia, korzystając z niezmiennego trybu globalizacji. Niezmienny tryb globalizacji jest przydatny w przypadku aplikacji, które nie są globalnie świadome i mogą używać konwencji formatowania, konwencji wielkości liter oraz porównania ciągów i kolejności sortowania niezmiennej kultury.

    Aby włączyć tryb niezmienny, kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksploratorze rozwiązań, a następnie wybierz polecenie Edytuj plik SCD.csproj lub Edytuj plik SCD.vbproj. Następnie dodaj następujące wyróżnione wiersze do pliku:

    <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. Utwórz kompilację debug aplikacji.

    Wybierz pozycję Kompiluj rozwiązanie kompilacji>. Możesz również skompilować i uruchomić kompilację debugowania aplikacji, wybierając pozycję Debuguj>rozpocznij debugowanie. Ten krok debugowania umożliwia zidentyfikowanie problemów z aplikacją, gdy jest ona uruchomiona na platformie hosta. Nadal trzeba będzie je przetestować na każdej z platform docelowych.

    Jeśli włączono tryb globalizacji niezmienny, należy szczególnie sprawdzić, czy brak danych wrażliwych na kulturę jest odpowiedni dla aplikacji.

Po zakończeniu debugowania możesz opublikować wdrożenie samodzielne:

Po przeprowadzeniu debugowania i testów programu utwórz pliki, które mają być wdrożone wraz z aplikacją dla każdej docelowej platformy.

Aby opublikować aplikację w programie Visual Studio, wykonaj następujące czynności:

  1. Zdefiniuj platformy docelowe aplikacji.

    1. Kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksploratorze rozwiązań i wybierz polecenie Edytuj plik SCD.csproj.

    2. <RuntimeIdentifiers> Utwórz tag w <PropertyGroup> sekcji pliku csproj, który definiuje platformy docelowe aplikacji i określ identyfikator środowiska uruchomieniowego (RID) każdej platformy docelowej. Należy również dodać średnik, aby oddzielić identyfikatory RID. Zobacz Wykaz identyfikatorów środowiska uruchomieniowego , aby uzyskać listę identyfikatorów środowiska uruchomieniowego.

    Na przykład poniższy przykład wskazuje, że aplikacja działa w 64-bitowych systemach operacyjnych Windows i 64-bitowym systemie operacyjnym OS X.

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

    W pliku <RuntimeIdentifiers> element <PropertyGroup> może przejść do dowolnego . Pełny przykładowy plik csproj zostanie wyświetlony w dalszej części tej sekcji.

  2. Opublikuj aplikację.

    Po przeprowadzeniu debugowania i testów programu utwórz pliki, które mają być wdrożone wraz z aplikacją dla każdej docelowej platformy.

    Aby opublikować aplikację w programie Visual Studio, wykonaj następujące czynności:

    1. Zmień konfigurację rozwiązania z Debuguj na Wydanie na pasku narzędzi, aby utworzyć wersję wydania (a nie debugowania) aplikacji.

    2. Kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksploratorze rozwiązań i wybierz pozycję Publikuj.

    3. Na karcie Publikowanie wybierz pozycję Publikuj. Program Visual Studio zapisuje pliki składające się na aplikację do lokalnego systemu plików.

    4. Na karcie Publikowanie jest teraz wyświetlany pojedynczy profil FolderProfile. Ustawienia konfiguracji profilu są wyświetlane w sekcji Podsumowanie na karcie. Docelowe środowisko uruchomieniowe określa, które środowisko uruchomieniowe zostało opublikowane, a lokalizacja docelowa określa miejsce zapisu plików dla wdrożenia samodzielnego.

    5. Program Visual Studio domyślnie zapisuje wszystkie opublikowane pliki w jednym katalogu. Dla wygody najlepiej utworzyć oddzielne profile dla każdego docelowego środowiska uruchomieniowego i umieścić opublikowane pliki w katalogu specyficznym dla platformy. Obejmuje to utworzenie oddzielnego profilu publikowania dla każdej platformy docelowej. Teraz ponownie skompiluj aplikację dla każdej platformy, wykonując następujące czynności:

      1. Wybierz pozycję Utwórz nowy profil w oknie dialogowym Publikowanie .

      2. W oknie dialogowym Wybieranie miejsca docelowego publikowania zmień lokalizację folderuna bin\Release\PublishOutput\win-x64. Kliknij przycisk OK.

      3. Wybierz nowy profil (FolderProfile1) na liście profilów i upewnij się, że docelowe środowisko uruchomieniowe ma wartość win-x64. Jeśli tak nie jest, wybierz pozycję Ustawienia. W oknie dialogowym Ustawienia profilu zmień docelowe środowisko uruchomieniowe na win-x64 i wybierz pozycję Zapisz. W przeciwnym razie wybierz pozycję Anuluj.

      4. Wybierz pozycję Publikuj, aby opublikować aplikację dla 64-bitowych platform systemu Windows 10.

      5. Ponownie wykonaj poprzednie kroki, aby utworzyć profil dla platformy osx-x64 . Lokalizacja docelowa to bin\Release\PublishOutput\osx-x64, a docelowe środowisko uruchomieniowe to osx-x64. Nazwa przypisana przez program Visual Studio do tego profilu to FolderProfile2.

    Każda lokalizacja docelowa zawiera pełny zestaw plików (zarówno plików aplikacji, jak i wszystkich plików platformy .NET Core) wymaganych do uruchomienia aplikacji.

Wraz z plikami aplikacji proces publikowania emituje plik bazy danych programu (.pdb), który zawiera informacje o debugowaniu aplikacji. Plik jest przydatny głównie w przypadku debugowania wyjątków. Możesz zdecydować się nie pakować go z plikami aplikacji. Należy jednak zapisać go na wypadek, gdybyś chciał debugować kompilację w wersji Release swojej aplikacji.

Wdróż opublikowane pliki w dowolny sposób. Możesz na przykład spakować je w pliku Zip, użyć prostego copy polecenia lub wdrożyć je przy użyciu dowolnego wybranego pakietu instalacyjnego.

Poniżej znajduje się kompletny plik csproj dla tego projektu.

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

Samodzielne wdrażanie z zależnościami od firm trzecich

Wdrożenie w trybie samodzielnym z jedną lub więcej zależnościami od firm trzecich polega na dodaniu tych zależności. Przed utworzeniem aplikacji wymagane są następujące dodatkowe kroki:

  1. Użyj Menedżera pakietów NuGet , aby dodać odwołanie do pakietu NuGet do projektu; a jeśli pakiet nie jest jeszcze dostępny w systemie, zainstaluj go. Aby otworzyć menedżera pakietów, wybierz pozycję Narzędzia> Menedżer >Zarządzaj pakietami NuGet dla rozwiązania.

  2. Upewnij się, że zależności innych firm (na przykład Newtonsoft.Json) są zainstalowane w systemie i, jeśli nie, zainstaluj je. Karta Zainstalowane zawiera listę pakietów NuGet zainstalowanych w systemie. Jeśli Newtonsoft.Json nie jest wymieniony na liście, wybierz kartę Przeglądaj i wpisz "Newtonsoft.Json" w polu wyszukiwania. Wybierz pozycję Newtonsoft.Json i w okienku po prawej stronie wybierz projekt przed wybraniem pozycji Zainstaluj.

  3. Jeśli Newtonsoft.Json jest już zainstalowany w Twoim systemie, dodaj go do projektu, wybierając go w okienku po prawej stronie w karcie Zarządzanie pakietami dla rozwiązania.

Poniżej znajduje się kompletny plik csproj dla tego projektu:

<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>

Podczas wdrażania aplikacji wszystkie zależności innych firm używane w aplikacji są również zawarte w plikach aplikacji. Biblioteki innych firm nie są wymagane w systemie, w którym aplikacja jest uruchomiona.

Wdrożenie samodzielne można wdrożyć tylko przy użyciu biblioteki innej firmy na platformach obsługiwanych przez tę bibliotekę. Jest to podobne do sytuacji, gdy masz zależności od firm trzecich z zależnościami natywnymi we wdrożeniu zależnym od platformy, gdzie zależności natywne nie będą dostępne na docelowej platformie, chyba że zostały tam zainstalowane wcześniej.

Zobacz także