Wdrażanie platformy .NET Core z aplikacji za pomocą programu Visual StudioDeploying .NET Core apps with Visual Studio

Możesz wdrożyć aplikację platformy .NET Core albo jako wdrożenia zależny od struktury, który zawiera pliki binarne aplikacji, ale zależy od obecności platformy .NET Core w systemie docelowym lub jako niezależna wdrożenie, który zawiera aplikację i pliki binarne .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. Omówienie wdrażania aplikacji .NET Core, zobacz wdrożenie aplikacji programu .NET Core.For an overview of .NET Core application deployment, see .NET Core Application Deployment.

Poniższe sekcje pokazują, jak używać programu Microsoft Visual Studio do tworzenia następujących rodzajów wdrożenia:The following sections show how to use Microsoft Visual Studio to create the following kinds of deployments:

  • Wdrożenie zależny od strukturyFramework-dependent deployment
  • Wdrażanie zależny od struktury za pomocą zależności innych firmFramework-dependent deployment with third-party dependencies
  • Niezależne wdrożeniaSelf-contained deployment
  • Niezależne wdrożenia przy użyciu zależności innych firmSelf-contained deployment with third-party dependencies

Aby uzyskać informacje na temat korzystania z programu Visual Studio do opracowywania aplikacji platformy .NET Core, zobacz wymagania wstępne dla platformy .NET Core w Windows.For information on using Visual Studio to develop .NET Core applications, see Prerequisites for .NET Core on Windows.

Wdrożenie zależny od strukturyFramework-dependent deployment

Wdrożenie zależny od struktury bez zależności innych firm po prostu polega na tworzenia, testowania i publikowania aplikacji.Deploying a framework-dependent deployment with no third-party dependencies simply involves building, testing, and publishing the app. Prosty przykład napisany w języku C# przedstawiono proces.A simple example written in C# illustrates the process.

  1. Utwórz projekt.Create the project.

    Wybierz pliku > nowe > projektu.Select File > New > Project. W nowy projekt okno dialogowe, rozwiń węzeł kategorii danego języka (C# lub Visual Basic) projektu w zainstalowane okienku typów projektu, wybierz polecenie platformy .NET Core, a następnie wybierz pozycję Aplikacja konsoli (.NET Core) szablonów w środkowym okienku.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. Wprowadź nazwę projektu, takich jak "Dyskietki" w nazwa pola tekstowego.Enter a project name, such as "FDD", in the Name text box. Wybierz OK przycisku.Select the OK button.

  2. Dodawanie kodu źródłowego aplikacji.Add the application's source code.

    Otwórz Program.cs lub Program.vb w edytorze i Zastęp automatycznie wygenerowany kod następującym kodem.Open the Program.cs or Program.vb file in the editor and replace the auto-generated code with the following code. On monituje użytkownika o wprowadzenie tekstu i wyświetla poszczególne wyrazy wprowadzonej przez użytkownika.It prompts the user to enter text and displays the individual words entered by the user. Używa wyrażenia regularnego \w+ do oddzielania słów w tekście wejściowym.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("\nPress 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. Utworzenie kompilacja do debugowania aplikacji.Create a Debug build of your app.

    Wybierz kompilacji > Kompiluj rozwiązanie.Select Build > Build Solution. Można również skompilować i uruchomić kompilację debugowania aplikacji, wybierając debugowania > Rozpocznij debugowanie.You can also compile and run the Debug build of your application by selecting Debug > Start Debugging.

  4. Wdrażanie aplikacji.Deploy your app.

    Po utworzeniu debugowania i przetestować program, należy utworzyć plików do wdrożenia z aplikacją.After you've debugged and tested the program, create the files to be deployed with your app. Aby opublikować z programu Visual Studio, wykonaj następujące czynności:To publish from Visual Studio, do the following:

    1. Zmień konfigurację przy użyciu rozwiązania debugowania do wersji na pasku narzędzi do kompilacji w wersji (a nie na debugowanie) wersję aplikacji.Change the solution configuration from Debug to Release on the toolbar to build a Release (rather than a Debug) version of your app.

    2. Kliknij prawym przyciskiem myszy nad projektem (nie rozwiązanie) Eksploratora rozwiązań i wybierz Publikuj.Right-click on the project (not the solution) in Solution Explorer and select Publish.

    3. W Publikuj zaznacz Publikuj.In the Publish tab, select Publish. Program Visual Studio zapisuje pliki, wchodzące w skład aplikacji w lokalnym systemie plików.Visual Studio writes the files that comprise your application to the local file system.

    4. Publikuj karta zawiera teraz jeden profil FolderProfile.The Publish tab now shows a single profile, FolderProfile. Ustawienia konfiguracji w profilu są wyświetlane w Podsumowanie karcie.The profile's configuration settings are shown in the Summary section of the tab.

    Pliki wynikowe są umieszczane w katalogu o nazwie Publish na Windows i publish na komputerach z systemem Unix, które znajduje się w podkatalogu projektu .\bin\release\netcoreapp2.1 podkatalogu.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.

Wraz z plikami aplikacji proces publikowania emituje plik bazy danych (PDB) program, który zawiera informacje o debugowaniu dotyczących aplikacji.Along with your application's files, the publishing process emits a program database (.pdb) file that contains debugging information about your app. Plik jest przydatne głównie do debugowania wyjątków.The file is useful primarily for debugging exceptions. Istnieje możliwość nie spakujesz ją z plikami aplikacji.You can choose not to package it with your application's files. Jednak należy je zapisać, w przypadku, gdy chcesz debugować kompilację wydania aplikacji.You should, however, save it in the event that you want to debug the Release build of your app.

Wdróż kompletny zestaw plików aplikacji w jakikolwiek sposób, który chcesz.Deploy the complete set of application files in any way you like. Na przykład, można umieścić je w pliku Zip, użyć prostego copy polecenie lub wdrożyć je przy użyciu dowolnego pakietu instalacyjnego wybranych przez użytkownika.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. Po zainstalowaniu, użytkownicy mogą następnie wykonać aplikacji przy użyciu dotnet polecenia i podając nazwę pliku aplikacji, takich jak 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.

Oprócz plików binarnych aplikacji Instalatora należy również pakietu Instalatora udostępnionego framework albo Wyszukaj jako warunek wstępny jako część instalacji aplikacji.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. Instalacja udostępnionego framework wymaga dostępu administratora/root, ponieważ jest ono komputera.Installation of the shared framework requires Administrator/root access since it is machine-wide.

Wdrażanie zależny od struktury za pomocą zależności innych firmFramework-dependent deployment with third-party dependencies

Wdrożenie zależny od struktury z co najmniej jeden zależności innych firm wymaga, aby wszystkie zależności dostępne dla projektu.Deploying a framework-dependent deployment with one or more third-party dependencies requires that any dependencies be available to your project. Przed utworzeniem aplikacji wymagane są następujące dodatkowe czynności:The following additional steps are required before you can build your app:

  1. Użyj Menedżera pakietów NuGet Dodaj odwołanie do pakietu NuGet do projektu; i jeśli pakiet nie jest jeszcze dostępna w systemie, zainstaluj go.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. Aby otworzyć Menedżera pakietów, wybierz narzędzia > Menedżera pakietów NuGet > Zarządzaj pakietami NuGet dla rozwiązania.To open the package manager, select Tools > NuGet Package Manager > Manage NuGet Packages for Solution.

  2. Upewnij się, że Newtonsoft.Json jest zainstalowana w systemie, a jeśli tak nie jest, zainstaluj go.Confirm that Newtonsoft.Json is installed on your system and, if it is not, install it. Zainstalowane karcie znajduje się lista pakietów NuGet, zainstalowanych w systemie.The Installed tab lists NuGet packages installed on your system. Jeśli Newtonsoft.Json nie ma na liście, wybierz Przeglądaj kartę, a następnie wprowadź "Newtonsoft.Json" w polu wyszukiwania.If Newtonsoft.Json is not listed there, select the Browse tab and enter "Newtonsoft.Json" in the search box. Wybierz Newtonsoft.Json i w okienku po prawej stronie, wybierz swój projekt przed wybraniem zainstalować.Select Newtonsoft.Json and, in the right pane, select your project before selecting Install.

  3. Jeśli Newtonsoft.Json jest już zainstalowany w systemie, dodaj go do projektu, wybierając projekt w prawym okienku Zarządzaj pakietami dla rozwiązania kartę.If Newtonsoft.Json is already installed on your system, add it to your project by selecting your project in the right pane of hte Manage Packages for Solution tab.

Należy pamiętać, że wdrożenie zależny od struktury z zależności innych firm tylko jako przenośne jako jego zależności innych firm.Note that a framework-dependent deployment with third-party dependencies is only as portable as its third-party dependencies. Na przykład jeśli biblioteki innych firm obsługuje tylko z systemem macOS, aplikacja nie jest przenośny z systemami Windows.For example, if a third-party library only supports macOS, the app isn't portable to Windows systems. Dzieje się tak, jeśli zależności innych firm, sama jest zależna od kodu natywnego.This happens if the third-party dependency itself depends on native code. Dobrym przykładem jest serwera Kestrel, co wymaga zależności natywnych na libuv.A good example of this is Kestrel server, which requires a native dependency on libuv. Podczas tworzenia Dyskietki dla aplikacji za pomocą tego rodzaju zależności innych firm opublikowane dane wyjściowe zawiera folder dla każdego identyfikator środowiska uruchomieniowego (RID) obsługującego natywnych zależności (i znajdujące się w pakiecie 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).

Niezależne wdrożenia bez zależności innych firmSelf-contained deployment without third-party dependencies

Wdrożenie niezależna bez zależności innych firm obejmuje tworzenie projektu i modyfikując csproj pliku, tworzenia, testowania i publikowania aplikacji.Deploying a self-contained deployment with no third-party dependencies involves creating the project, modifying the csproj file, building, testing, and publishing the app. Prosty przykład napisany w języku C# przedstawiono proces.A simple example written in C# illustrates the process. Należy rozpocząć od tworzenia, kodowania i testowania projektu, tak samo jak wdrożenia zależny od struktury:You begin by creating, coding, and testing your project just as you would a framework-dependent deployment:

  1. Utwórz projekt.Create the project.

    Wybierz pliku > nowe > projektu.Select File > New > Project. W nowy projekt okno dialogowe, rozwiń węzeł kategorii danego języka (C# lub Visual Basic) projektu w zainstalowane okienku typów projektu, wybierz polecenie platformy .NET Core, a następnie wybierz pozycję Aplikacja konsoli (.NET Core) szablonów w środkowym okienku.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. Wprowadź nazwę projektu, takich jak "— SCD", w nazwa pola tekstowego, a następnie wybierz pozycję OK przycisku.Enter a project name, such as "SCD", in the Name text box, and select the OK button.

  2. Dodawanie kodu źródłowego aplikacji.Add the application's source code.

    Otwórz Program.cs lub plik w edytorze i Zastąp kod wygenerowany automatycznie z następującym kodem.Open the Program.cs or file in your editor, and replace the auto-generated code with the following code. On monituje użytkownika o wprowadzenie tekstu i wyświetla poszczególne wyrazy wprowadzonej przez użytkownika.It prompts the user to enter text and displays the individual words entered by the user. Używa wyrażenia regularnego \w+ do oddzielania słów w tekście wejściowym.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("\nPress 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 używać globalizacji niezmiennej trybu.Determine whether you want to use globalization invariant mode.

    Szczególnie w przypadku, gdy aplikacja jest przeznaczona na systemie Linux, można zmniejszyć całkowity rozmiar wdrożenia, wykorzystując globalizacji niezmiennej tryb.Particularly if your app targets Linux, you can reduce the total size of your deployment by taking advantage of globalization invariant mode. Globalizacji niezmiennej tryb jest przydatne w przypadku aplikacji, które nie są wspierane i mogą używać konwencji formatowania Konwencji obudowy i ciąg porównywania i sortowania kolejności niezmiennej kultury.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.

    Aby włączyć tryb niezmiennej, kliknij prawym przyciskiem myszy nad projektem (nie rozwiązanie) Eksploratora rozwiązańi wybierz Edytuj SCD.csproj lub Edytuj 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. Następnie dodaj następujące wiersze wyróżnione do pliku:Then add the following highlighted lines to the file:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <RuntimeHostConfigurationOption Include="System.Globalization.Invariant" Value="true" />
  </ItemGroup> 
</Project>
  1. Utworzenie kompilacja do debugowania aplikacji.Create a Debug build of your application.

    Wybierz kompilacji > Kompiluj rozwiązanie.Select Build > Build Solution. Można również skompilować i uruchomić kompilację debugowania aplikacji, wybierając debugowania > Rozpocznij debugowanie.You can also compile and run the Debug build of your application by selecting Debug > Start Debugging. Ten krok debugowania pozwala zidentyfikować problemy z aplikacji, gdy jest uruchomiona na platformie hosta.This debugging step lets you identify problems with your application when it's running on your host platform. Nadal trzeba będzie je przetestować na każdej z platform docelowych.You still will have to test it on each of your target platforms.

    Po włączeniu trybu niezmiennej globalizacji, należy szczególnie sprawdzić, czy brak dane wrażliwe na ustawienia kulturowe jest odpowiedni dla twojej aplikacji.If you've enabled globalization invariant mode, be particularly sure to test whether the absence of culture-sensitive data is suitable for your application.

Po zakończeniu debugowania, możesz opublikować niezależna wdrożenia:Once you've finished debugging, you can publish your self-contained deployment:

Po utworzeniu debugowania i przetestować program, należy utworzyć pliki do wdrożenia z aplikacją, dotyczącymi poszczególnych platform, że jest ono przeznaczone dla.After you've debugged and tested the program, create the files to be deployed with your app for each platform that it targets.

Aby opublikować aplikację z poziomu programu Visual Studio, wykonaj następujące czynności:To publish your app from Visual Studio, do the following:

  1. Zdefiniuj platformy, dla których będzie dotyczyć aplikacji.Define the platforms that your app will target.

    1. Kliknij prawym przyciskiem myszy nad projektem (nie rozwiązanie) Eksploratora rozwiązań i wybierz Edytuj SCD.csproj.Right-click on your project (not the solution) in Solution Explorer and select Edit SCD.csproj.

    2. Tworzenie <RuntimeIdentifiers> tagów w <PropertyGroup> części Twojej csproj pliku, który definiuje Twojej aplikacji jest przeznaczony dla platform i podaj identyfikator środowiska uruchomieniowego (RID) każdej z platform docelowych.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. Należy zauważyć, że trzeba będzie również dodać średnika do rozdzielenia identyfikatorów RID.Note that you also need to add a semicolon to separate the RIDs. Zobacz katalog identyfikatora środowiska uruchomieniowego Lista identyfikatorów środowisk uruchomieniowych.See Runtime IDentifier catalog for a list of runtime identifiers.

    Na przykład w poniższym przykładzie wskazuje, że aplikacja działa w 64-bitowych systemach operacyjnych Windows 10 i 64-bitowym systemie operacyjnym OS X w wersji 10.11.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>
    

    Należy pamiętać, że <RuntimeIdentifiers> przejść do dowolnego elementu <PropertyGroup> zainstalowanej w swojej csproj pliku.Note that the <RuntimeIdentifiers> element can go into any <PropertyGroup> that you have in your csproj file. Pełny przykład csproj plik pojawia się w dalszej części w tej sekcji.A complete sample csproj file appears later in this section.

  2. Opublikuj aplikację.Publish your app.

    Po utworzeniu debugowania i przetestować program, należy utworzyć pliki do wdrożenia z aplikacją, dotyczącymi poszczególnych platform, że jest ono przeznaczone dla.After you've debugged and tested the program, create the files to be deployed with your app for each platform that it targets.

    Aby opublikować aplikację z poziomu programu Visual Studio, wykonaj następujące czynności:To publish your app from Visual Studio, do the following:

    1. Zmień konfigurację przy użyciu rozwiązania debugowania do wersji na pasku narzędzi do kompilacji w wersji (a nie na debugowanie) wersję aplikacji.Change the solution configuration from Debug to Release on the toolbar to build a Release (rather than a Debug) version of your app.

    2. Kliknij prawym przyciskiem myszy nad projektem (nie rozwiązanie) Eksploratora rozwiązań i wybierz Publikuj.Right-click on the project (not the solution) in Solution Explorer and select Publish.

    3. W Publikuj zaznacz Publikuj.In the Publish tab, select Publish. Program Visual Studio zapisuje pliki, wchodzące w skład aplikacji w lokalnym systemie plików.Visual Studio writes the files that comprise your application to the local file system.

    4. Publikuj karta zawiera teraz jeden profil FolderProfile.The Publish tab now shows a single profile, FolderProfile. Ustawienia konfiguracji w profilu są wyświetlane w Podsumowanie karcie. Docelowe środowisko uruchomieniowe identyfikuje, które środowisko uruchomieniowe zostało opublikowane, a lokalizacji docelowej identyfikuje, gdzie zostały napisane pliki niezależne wdrożenia.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. Visual Studio domyślnie zapisuje pliki wszystkie opublikowane w jednym katalogu.Visual Studio by default writes all published files to a single directory. Dla wygody najlepiej jest utworzyć osobne profile dla każdego docelowe środowisko uruchomieniowe i umieść pliki opublikowane w katalogu specyficzny dla platformy.For convenience, it's best to create separate profiles for each target runtime and to place published files in a platform-specific directory. Obejmuje to tworzenie oddzielny profil publikowania dla każdej platformy docelowej.This involves creating a separate publishing profile for each target platform. Teraz ponownie skompiluj aplikację dla każdej platformy, wykonując następujące czynności:So now rebuild the application for each platform by doing the following:

      1. Wybierz Utwórz nowy profil w Publikuj okna dialogowego.Select Create new profile in the Publish dialog.

      2. W wybierz lokalizację docelową publikowania okno dialogowe, zmiana wybierz folder lokalizację bin\Release\PublishOutput\win10 x64.In the Pick a publish target dialog, change the Choose a folder location to bin\Release\PublishOutput\win10-x64. Wybierz OK.Select OK.

      3. Wybierz nowy profil (FolderProfile1) na liście profilów i upewnij się, że docelowe środowisko uruchomieniowe jest win10-x64.Select the new profile (FolderProfile1) in the list of profiles, and make sure that the Target Runtime is win10-x64. Jeśli nie, wybierz ustawienia.If it isn't, select Settings. W ustawienia profilu okno dialogowe, zmiana docelowe środowisko uruchomieniowe do win10-x64 i wybierz Zapisz.In the Profile Settings dialog, change the Target Runtime to win10-x64 and select Save. W przeciwnym razie wybierz anulować.Otherwise, select Cancel.

      4. Wybierz Publikuj do publikowania aplikacji dla platformy Windows 10 w 64-bitowych.Select Publish to publish your app for 64-bit Windows 10 platforms.

      5. Wykonaj poprzednie kroki, aby utworzyć profil dla osx.10.11-x64 platformy.Follow the previous steps again to create a profile for the osx.10.11-x64 platform. Lokalizacji docelowej jest bin\Release\PublishOutput\osx.10.11-x64i docelowe środowisko uruchomieniowe jest osx.10.11-x64.The Target Location is bin\Release\PublishOutput\osx.10.11-x64, and the Target Runtime is osx.10.11-x64. Nazwa programu Visual Studio, przypisuje do tego profilu jest FolderProfile2.The name that Visual Studio assigns to this profile is FolderProfile2.

    Należy pamiętać, że każda lokalizacja docelowa zawiera kompletny zestaw plików (pliki aplikacji i wszystkich plików z platformy .NET Core) potrzebnych do uruchomienia aplikacji.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.

Wraz z plikami aplikacji proces publikowania emituje plik bazy danych (PDB) program, który zawiera informacje o debugowaniu dotyczących aplikacji.Along with your application's files, the publishing process emits a program database (.pdb) file that contains debugging information about your app. Plik jest przydatne głównie do debugowania wyjątków.The file is useful primarily for debugging exceptions. Istnieje możliwość nie spakujesz ją z plikami aplikacji.You can choose not to package it with your application's files. Jednak należy je zapisać, w przypadku, gdy chcesz debugować kompilację wydania aplikacji.You should, however, save it in the event that you want to debug the Release build of your app.

Wdrażanie plików publikowanych w jakikolwiek sposób, który chcesz.Deploy the published files in any way you like. Na przykład, można umieścić je w pliku Zip, użyć prostego copy polecenie lub wdrożyć je przy użyciu dowolnego pakietu instalacyjnego wybranych przez użytkownika.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.

Poniżej przedstawiono pełne csproj pliku dla tego projektu.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>

Niezależne wdrożenia przy użyciu zależności innych firmSelf-contained deployment with third-party dependencies

Niezależna wdrożenie z co najmniej jeden zależności innych firm obejmuje dodawanie zależności.Deploying a self-contained deployment with one or more third-party dependencies involves adding the dependencies. Przed utworzeniem aplikacji wymagane są następujące dodatkowe czynności:The following additional steps are required before you can build your app:

  1. Użyj Menedżera pakietów NuGet Dodaj odwołanie do pakietu NuGet do projektu; i jeśli pakiet nie jest jeszcze dostępna w systemie, zainstaluj go.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. Aby otworzyć Menedżera pakietów, wybierz narzędzia > Menedżera pakietów NuGet > Zarządzaj pakietami NuGet dla rozwiązania.To open the package manager, select Tools > NuGet Package Manager > Manage NuGet Packages for Solution.

  2. Upewnij się, że Newtonsoft.Json jest zainstalowana w systemie, a jeśli tak nie jest, zainstaluj go.Confirm that Newtonsoft.Json is installed on your system and, if it is not, install it. Zainstalowane karcie znajduje się lista pakietów NuGet, zainstalowanych w systemie.The Installed tab lists NuGet packages installed on your system. Jeśli Newtonsoft.Json nie ma na liście, wybierz Przeglądaj kartę, a następnie wprowadź "Newtonsoft.Json" w polu wyszukiwania.If Newtonsoft.Json is not listed there, select the Browse tab and enter "Newtonsoft.Json" in the search box. Wybierz Newtonsoft.Json i w okienku po prawej stronie, wybierz swój projekt przed wybraniem zainstalować.Select Newtonsoft.Json and, in the right pane, select your project before selecting Install.

  3. Jeśli Newtonsoft.Json jest już zainstalowany w systemie, dodaj go do projektu, wybierając projekt w prawym okienku Zarządzaj pakietami dla rozwiązania kartę.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.

Poniżej przedstawiono pełne csproj pliku dla tego projektu: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>

Podczas wdrażania aplikacji, wszelkie zależności innych firm używanych w aplikacji znajdują się również z plikami aplikacji.When you deploy your application, any third-party dependencies used in your app are also contained with your application files. Bibliotek innych firm nie są wymagane w systemie, na którym działa aplikacja.Third-party libraries aren't required on the system on which the app is running.

Należy pamiętać, że można wdrożyć tylko niezależna wdrożenia przy użyciu biblioteki innej firmy na platformach obsługiwanych przez tej biblioteki.Note that you can only deploy a self-contained deployment with a third-party library to platforms supported by that library. Jest to podobne do mających zależności innych firm za pomocą natywnego zależności w danym wdrożeniu zależny od struktury, gdzie zależności natywnych nie istnieje na platformie docelowej, chyba że zostały wcześniej zainstalowane istnieje.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.

Zobacz takżeSee also