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

Artykuł
03/02/2024

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
Wdrożenie samodzielne
Samodzielne wdrażanie z zależnościami innych firm

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

Wdrażanie wdrożenia zależnego od struktury bez zależności innych firm polega po prostu na tworzeniu, testowaniu i publikowaniu aplikacji. Prosty przykład napisany w języku C# ilustruje proces.

Utwórz projekt.

Wybierz kolejno pozycje 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.

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

Utwórz kompilację debugowania aplikacji.

Wybierz pozycję Kompiluj rozwiązanie kompilacji>. Możesz również skompilować i uruchomić kompilację debugowania aplikacji, wybierając pozycję Debuguj>rozpocznij debugowanie.
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 Debugujna Wydanie na pasku narzędzi, aby utworzyć wersję wydania (a nie debugowania) aplikacji.
2. Kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksplorator 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 systemie Windows i publish w systemach Unix, który znajduje się w podkatalogu podkatalogu .\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. Nie można spakować go przy użyciu plików aplikacji. Należy jednak zapisać go w przypadku, gdy chcesz debugować kompilację wydania 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 dotnet użytkownicy mogą następnie wykonywać aplikację za pomocą polecenia 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 Administracja istratora/dostępu 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 wdrożenia zależnego od struktury z co najmniej jedną zależnością innej firmy wymaga, aby wszystkie zależności dostępne w projekcie. Przed utworzeniem aplikacji wymagane są następujące dodatkowe kroki:

Użyj Menedżer 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>NuGet Menedżer pakietów> Zarządzanie pakietami NuGet dla rozwiązania.
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 ma go na liście, wybierz kartę Przeglądaj i wprowadź ciąg "Newtonsoft.Json" w polu wyszukiwania. Wybierz pozycję Newtonsoft.Json i w okienku po prawej stronie wybierz projekt przed wybraniem pozycji Zainstaluj.
Jeśli Newtonsoft.Json system jest już zainstalowany, dodaj go do projektu, wybierając projekt w okienku po prawej stronie karty Zarządzanie pakietami dla rozwiązania .

Wdrożenie zależne od struktury z zależnościami innych firm jest tylko przenośne jako 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 sama zależność innej firmy zależy od kodu natywnego. Dobrym przykładem jest serwer Kestrel, który wymaga natywnej zależności od biblioteki libuv. Po utworzeniu identyfikatora FDD dla aplikacji z tego rodzaju zależnościami innych firm opublikowane dane wyjściowe zawierają folder dla każdego identyfikatora środowiska uruchomieniowego (RID), który obsługuje natywna zależność (i istnieje w jego 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:

Utwórz projekt.

Wybierz kolejno pozycje 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 .

Dodaj kod źródłowy aplikacji.

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

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 Eksplorator rozwiązań, a następnie wybierz polecenie Edytuj plik SCD.csproj lub Edytuj 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>
```
Utwórz kompilację debugowania 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:

Program Visual Studio 15.6 i starsze wersje
Program Visual Studio 15.7 lub nowszy

Po debugowania i przetestowaniu programu utwórz pliki, które mają zostać wdrożone z aplikacją dla każdej platformy, której dotyczy.

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

Zdefiniuj platformy docelowe aplikacji.
1. Kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksplorator 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 ZAREZERWOWANE. 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>
```
Element <RuntimeIdentifiers> może przejść do dowolnego <PropertyGroup> elementu w pliku csproj . Pełny przykładowy plik csproj zostanie wyświetlony w dalszej części tej sekcji.
Opublikuj aplikację.

Po debugowania i przetestowaniu programu utwórz pliki, które mają zostać wdrożone z aplikacją dla każdej platformy, której dotyczy.

Aby opublikować aplikację w programie Visual Studio, wykonaj następujące czynności:
1. Zmień konfigurację rozwiązania z Debugujna Wydanie na pasku narzędzi, aby utworzyć wersję wydania (a nie debugowania) aplikacji.
2. Kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksplorator 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. Docelowe środowisko uruchomieniowe określa, które środowisko uruchomieniowe zostało opublikowane, a lokalizacja docelowa określa miejsce zapisywania 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ę folderu na bin\Release\PublishOutput\win-x64. Wybierz 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 Profil Ustawienia 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.

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>

Po debugowania i przetestowaniu programu utwórz pliki, które mają zostać wdrożone z aplikacją dla każdej platformy, której dotyczy. Obejmuje to utworzenie oddzielnego profilu dla każdej platformy docelowej.

Dla każdej platformy docelowej aplikacji wykonaj następujące czynności:

Utwórz profil dla platformy docelowej.

Jeśli jest to pierwszy utworzony profil, kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksplorator rozwiązań i wybierz polecenie Publikuj.

Jeśli profil został już utworzony, kliknij prawym przyciskiem myszy projekt, aby otworzyć okno dialogowe Publikowanie , jeśli jeszcze nie jest otwarte. Następnie wybierz pozycję Nowy profil.

Zostanie otwarte okno dialogowe Wybieranie obiektu docelowego publikowania.
Wybierz lokalizację, w której program Visual Studio publikuje aplikację.

Jeśli publikujesz tylko na jednej platformie, możesz zaakceptować wartość domyślną w polu tekstowym Wybierz folder . Spowoduje to opublikowanie wdrożenia aplikacji zależnej od struktury w <katalogu project-directory>\bin\Release\netcoreapp2.1\publish .

Jeśli publikujesz więcej niż jedną platformę, dołącz ciąg identyfikujący platformę docelową. Jeśli na przykład dołączysz ciąg "linux" do ścieżki pliku, program Visual Studio publikuje wdrożenie aplikacji zależne od struktury do <katalogu project-directory>\bin\Release\netcoreapp2.1\publish\linux .
Utwórz profil, wybierając ikonę listy rozwijanej obok przycisku Publikuj i wybierając pozycję Utwórz profil. Następnie wybierz przycisk Utwórz profil , aby utworzyć profil.
Wskaż, że publikujesz wdrożenie samodzielne i zdefiniuj platformę docelową aplikacji.
1. W oknie dialogowym Publikowanie wybierz link Konfiguruj, aby otworzyć okno dialogowe Profil Ustawienia.
2. Wybierz pozycję Samodzielna zawartość w polu Listy Tryb wdrażania.
3. W polu Listy Docelowe środowisko uruchomieniowe wybierz jedną z platform docelowych aplikacji.
4. Wybierz pozycję Zapisz , aby zaakceptować zmiany i zamknąć okno dialogowe.
Nadaj profilowi nazwę.
1. Wybierz pozycję Akcje>Zmień nazwę profilu, aby nazwać swój profil.
2. Przypisz swój profil nazwę identyfikującą platformę docelową, a następnie wybierz pozycję *Zapisz.

Powtórz te kroki, aby zdefiniować wszelkie dodatkowe platformy docelowe przeznaczone dla aplikacji.

Profile zostały skonfigurowane i są teraz gotowe do opublikowania aplikacji. Czynność:

Jeśli okno Publikowanie nie jest obecnie otwarte, kliknij prawym przyciskiem myszy projekt (a nie rozwiązanie) w Eksplorator rozwiązań i wybierz pozycję Publikuj.
Wybierz profil, który chcesz opublikować, a następnie wybierz pozycję Publikuj. Zrób to dla każdego profilu, który ma zostać opublikowany.

Każda lokalizacja docelowa (w naszym przykładzie bin\release\netcoreapp2.1\publish\profile-name) zawiera pełny zestaw plików (zarówno plików aplikacji, jak i wszystkich plików platformy .NET Core) wymaganych do uruchomienia 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>
  </PropertyGroup>
</Project>

Ponadto program Visual Studio tworzy oddzielny profil publikowania (*.pubxml) dla każdej docelowej platformy. Na przykład plik naszego profilu systemu Linux (linux.pubxml) jest wyświetlany w następujący sposób:

<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <PublishProtocol>FileSystem</PublishProtocol>
    <Configuration>Release</Configuration>
    <Platform>Any CPU</Platform>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <PublishDir>bin\Release\netcoreapp2.1\publish\linux</PublishDir>
    <RuntimeIdentifier>win-x86</RuntimeIdentifier>
    <SelfContained>true</SelfContained>
    <_IsPortable>false</_IsPortable>
  </PropertyGroup>
</Project>

Samodzielne wdrażanie z zależnościami innych firm

Wdrożenie samodzielnego wdrożenia z co najmniej jedną zależnością innej firmy polega na dodaniu zależności. Przed utworzeniem aplikacji wymagane są następujące dodatkowe kroki:

Użyj Menedżer 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>NuGet Menedżer pakietów> Zarządzanie pakietami NuGet dla rozwiązania.
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 ma go na liście, wybierz kartę Przeglądaj i wprowadź ciąg "Newtonsoft.Json" w polu wyszukiwania. Wybierz pozycję Newtonsoft.Json i w okienku po prawej stronie wybierz projekt przed wybraniem pozycji Zainstaluj.
Jeśli Newtonsoft.Json system jest już zainstalowany, dodaj go do projektu, wybierając projekt w okienku po prawej stronie karty Zarządzanie pakietami dla rozwiązania .

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

Program Visual Studio 15.6 i starsze wersje
Program Visual Studio 15.7 lub nowszy

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

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </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 zależności innych firm z zależnościami natywnymi we wdrożeniu zależnym od platformy, gdzie zależności natywne nie będą istnieć na platformie docelowej, chyba że zostały zainstalowane wcześniej.

Udostępnij za pośrednictwem

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

Wdrożenie zależne od struktury

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

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

Samodzielne wdrażanie z zależnościami innych firm

Zobacz też

Dodatkowe zasoby