Freigeben über

Bereitstellen von .NET Core-Apps mit Visual Studio

Sie können eine .NET Core-Anwendung entweder als frameworkabhängige Bereitstellung bereitstellen, die Ihre Anwendungsbinärdateien enthält, aber von dem Vorhandensein von .NET Core auf dem Zielsystem oder als eigenständige Bereitstellung abhängt, die sowohl Ihre Anwendung als auch .NET Core-Binärdateien enthält. Eine Übersicht über die .NET Core-Anwendungsbereitstellung finden Sie unter .NET Core Application Deployment.

In den folgenden Abschnitten wird gezeigt, wie Sie Microsoft Visual Studio zum Erstellen der folgenden Arten von Bereitstellungen verwenden:

  • Framework-abhängige Bereitstellung
  • Frameworkabhängige Bereitstellung mit Abhängigkeiten von Drittanbietern
  • Eigenständige Bereitstellung
  • Eigenständige Bereitstellung mit Abhängigkeiten von Drittanbietern

Informationen zur Verwendung von Visual Studio zum Entwickeln von .NET Core-Anwendungen finden Sie unter .NET Core-Abhängigkeiten und -Anforderungen.

Framework-abhängige Bereitstellung

Die Bereitstellung einer frameworkabhängigen Bereitstellung ohne Abhängigkeiten von Drittanbietern umfasst lediglich das Erstellen, Testen und Veröffentlichen der App. Ein einfaches Beispiel in C# veranschaulicht den Prozess.

  1. Erstellen eines Projekts

    Wählen Sie Datei>Neu>Projekt aus. Erweitern Sie im Dialogfeld "Neues Projekt " die Projektkategorien Ihrer Sprache (C# oder Visual Basic) im Bereich "Installierte Projekttypen", wählen Sie .NET Core aus, und wählen Sie dann im mittleren Bereich die Vorlage "Konsolen-App (.NET Core)" aus. Geben Sie im Textfeld "Name " einen Projektnamen ein, z. B. "FDD". Klicken Sie auf die Schaltfläche OK.

  2. Fügen Sie den Quellcode der Anwendung hinzu.

    Öffnen Sie die datei Program.cs oder Program.vb im Editor, und ersetzen Sie den automatisch generierten Code durch den folgenden Code. Er fordert den Benutzer auf, Text einzugeben, und zeigt die einzelnen Wörter an, die vom Benutzer eingegeben wurden. Er verwendet den regulären Ausdruck \w+ , um die Wörter im Eingabetext zu trennen.

    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. Erstellen Sie einen Debugbuild Ihrer App.

    Wählen Sie Build Solution (Projektmappe erstellen>)aus. Sie können den Debugbuild Ihrer Anwendung auch kompilieren und ausführen, indem Sie "Debuggen>starten" auswählen.

  4. Stellen Sie Ihre App bereit.

    Nachdem Sie das Programm gedebuggt und getestet haben, erstellen Sie die Dateien, die mit Ihrer App bereitgestellt werden sollen. Gehen Sie wie folgt vor, um aus Visual Studio zu veröffentlichen:

    1. Ändern Sie die Lösungskonfiguration von "Debuggen " in " Release " auf der Symbolleiste, um eine Releaseversion (anstelle einer Debugversion) Ihrer App zu erstellen.

    2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt (nicht auf die Projektmappe), und wählen Sie "Veröffentlichen" aus.

    3. Wählen Sie auf der Registerkarte " Veröffentlichen " die Option "Veröffentlichen" aus. Visual Studio schreibt die Dateien, aus denen Ihre Anwendung besteht, in das lokale Dateisystem.

    4. Auf der Registerkarte " Veröffentlichen " wird jetzt ein einzelnes Profil " FolderProfile" angezeigt. Die Konfigurationseinstellungen des Profils werden im Abschnitt "Zusammenfassung " der Registerkarte angezeigt.

    Die resultierenden Dateien werden in einem Verzeichnis unter Publish Windows und publish auf Unix-Systemen gespeichert, das sich in einem Unterverzeichnis des .\bin\release\netcoreapp2.1-Unterverzeichnis befindet.

Zusammen mit den Dateien Ihrer Anwendung gibt der Veröffentlichungsprozess eine Programmdatenbankdatei (PDB) aus, die Debuginformationen zu Ihrer App enthält. Die Datei ist in erster Linie für das Debuggen von Ausnahmen nützlich. Sie können auswählen, dass sie nicht mit den Dateien Ihrer Anwendung verpackt werden soll. Sie sollten sie jedoch speichern, wenn Sie den Releasebuild Ihrer App debuggen möchten.

Stellen Sie den vollständigen Satz von Anwendungsdateien auf beliebige Weise bereit. Sie können sie beispielsweise in einer ZIP-Datei verpacken, einen einfachen copy Befehl verwenden oder mit einem beliebigen Installationspaket ihrer Wahl bereitstellen. Nach der Installation können Benutzer Ihre Anwendung dann mit dem dotnet Befehl ausführen und den Anwendungsdateinamen angeben, z dotnet fdd.dll. B. .

Zusätzlich zu den Anwendungsbinärdateien sollte ihr Installationsprogramm entweder das freigegebene Framework-Installationsprogramm bündeln oder als Voraussetzung für die Anwendungsinstallation überprüfen. Die Installation des freigegebenen Frameworks erfordert Administrator-/Stammzugriff, da es computerweit ist.

Frameworkabhängige Bereitstellung mit Abhängigkeiten von Drittanbietern

Für die Bereitstellung einer frameworkabhängigen Bereitstellung mit einer oder mehreren Abhängigkeiten von Drittanbietern müssen Abhängigkeiten für Ihr Projekt verfügbar sein. Die folgenden zusätzlichen Schritte sind erforderlich, bevor Sie Ihre App erstellen können:

  1. Verwenden Sie den NuGet-Paket-Manager , um ihrem Projekt einen Verweis auf ein NuGet-Paket hinzuzufügen. und wenn das Paket noch nicht auf Ihrem System verfügbar ist, installieren Sie es. Um den Paket-Manager zu öffnen, wählen Sie "Tools>NuGet Package Manager>Manage NuGet Packages for Solution" aus.

  2. Vergewissern Sie sich, dass Ihre Abhängigkeiten von Drittanbietern (z Newtonsoft.Json. B. ) auf Ihrem System installiert sind, und installieren Sie sie, falls nicht, sie. Auf der Registerkarte "Installiert " sind NuGet-Pakete aufgeführt, die auf Ihrem System installiert sind. Wenn Newtonsoft.Json dort nicht aufgeführt ist, wählen Sie die Registerkarte "Durchsuchen " aus, und geben Sie "Newtonsoft.Json" in das Suchfeld ein. Wählen Sie Newtonsoft.Json im rechten Bereich Ihr Projekt aus, bevor Sie "Installieren" auswählen.

  3. Wenn Newtonsoft.Json sie bereits auf Ihrem System installiert ist, fügen Sie es zu Ihrem Projekt hinzu, indem Sie ihr Projekt im rechten Bereich der Registerkarte " Pakete für Lösung verwalten " auswählen.

Eine frameworkabhängige Bereitstellung mit Abhängigkeiten von Drittanbietern ist nur so portabel wie die Abhängigkeiten von Drittanbietern. Wenn beispielsweise eine Drittanbieterbibliothek nur macOS unterstützt, ist die App nicht portierbar für Windows-Systeme. Dies geschieht, wenn die Abhängigkeit von Drittanbietern selbst vom systemeigenen Code abhängt. Ein gutes Beispiel hierfür ist der Kestrel-Server, der eine systemeigene Abhängigkeit von libuv erfordert. Wenn eine FDD für eine Anwendung mit dieser Art von Abhängigkeit von Drittanbietern erstellt wird, enthält die veröffentlichte Ausgabe einen Ordner für jeden Runtime Identifier (RID), den die systemeigene Abhängigkeit unterstützt (und die im NuGet-Paket vorhanden ist).

Eigenständige Bereitstellung ohne Abhängigkeiten von Drittanbietern

Die Bereitstellung einer eigenständigen Bereitstellung ohne Abhängigkeiten von Drittanbietern umfasst das Erstellen des Projekts, das Ändern der csproj-Datei , das Erstellen, Testen und Veröffentlichen der App. Ein einfaches Beispiel in C# veranschaulicht den Prozess. Sie beginnen mit dem Erstellen, Codieren und Testen Ihres Projekts wie bei einer frameworkabhängigen Bereitstellung:

  1. Erstellen eines Projekts

    Wählen Sie Datei>Neu>Projekt aus. Erweitern Sie im Dialogfeld "Neues Projekt " die Projektkategorien Ihrer Sprache (C# oder Visual Basic) im Bereich "Installierte Projekttypen", wählen Sie .NET Core aus, und wählen Sie dann im mittleren Bereich die Vorlage "Konsolen-App (.NET Core)" aus. Geben Sie im Textfeld "Name " einen Projektnamen ein, z. B. "SCD", und wählen Sie die Schaltfläche "OK " aus.

  2. Fügen Sie den Quellcode der Anwendung hinzu.

    Öffnen Sie die datei Program.cs oder Program.vb im Editor, und ersetzen Sie den automatisch generierten Code durch den folgenden Code. Er fordert den Benutzer auf, Text einzugeben, und zeigt die einzelnen Wörter an, die vom Benutzer eingegeben wurden. Er verwendet den regulären Ausdruck \w+ , um die Wörter im Eingabetext zu trennen.

    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. Bestimmen Sie, ob Sie den invarianten Modus der Globalisierung verwenden möchten.

    Besonders wenn Ihre App auf Linux ausgerichtet ist, können Sie die Gesamtgröße Ihrer Bereitstellung reduzieren, indem Sie den globalisierungsinvarianten Modus nutzen. Der invariante Modus der Globalisierung ist nützlich für Anwendungen, die nicht global bekannt sind und die Formatierungskonventionen, Groß-/Kleinschreibungskonventionen und Zeichenfolgenvergleiche und Sortierreihenfolge der invarianten Kultur verwenden können.

    Um den invarianten Modus zu aktivieren, klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt (nicht auf die Projektmappe), und wählen Sie "SCD.csprojbearbeiten" oder "SCD.vbproj bearbeiten" aus. Fügen Sie dann der Datei die folgenden hervorgehobenen Zeilen hinzu:

    <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. Erstellen Sie einen Debugbuild Ihrer Anwendung.

    Wählen Sie Build Solution (Projektmappe erstellen>)aus. Sie können den Debugbuild Ihrer Anwendung auch kompilieren und ausführen, indem Sie "Debuggen>starten" auswählen. Mit diesem Debugschritt können Sie Probleme mit Ihrer Anwendung identifizieren, wenn sie auf Ihrer Hostplattform ausgeführt wird. Sie müssen sie immer noch auf den einzelnen Zielplattformen testen.

    Wenn Sie den invarianten Modus der Globalisierung aktiviert haben, sollten Sie insbesondere testen, ob das Fehlen von kultursensiblen Daten für Ihre Anwendung geeignet ist.

Nachdem Sie das Debuggen abgeschlossen haben, können Sie Ihre eigenständige Bereitstellung veröffentlichen:

Nachdem Sie das Programm gedebuggt und getestet haben, erstellen Sie die Dateien, die mit Ihrer App für jede Plattform bereitgestellt werden sollen, auf die sie ausgerichtet ist.

Gehen Sie wie folgt vor, um Ihre App aus Visual Studio zu veröffentlichen:

  1. Definieren Sie die Plattformen, auf die Ihre App ausgerichtet ist.

    1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt (nicht auf die Projektmappe), und wählen Sie "SCD.csproj bearbeiten" aus.

    2. Erstellen Sie ein <RuntimeIdentifiers> Tag im <PropertyGroup> Abschnitt Ihrer csproj-Datei , die die Plattformen definiert, auf die Ihre App ausgerichtet ist, und geben Sie den Laufzeitbezeichner (RID) jeder Plattform an, auf die Sie abzielen. Sie müssen auch ein Semikolon hinzufügen, um die RIDs zu trennen. Eine Liste der Laufzeit-IDs finden Sie im Laufzeitbezeichnerkatalog .

    Im folgenden Beispiel wird beispielsweise angegeben, dass die App unter 64-Bit-Windows-Betriebssystemen und dem 64-Bit-Betriebssystem OS X ausgeführt wird.

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

    Das <RuntimeIdentifiers> Element kann in jede <PropertyGroup> datei, die Sie in Ihrer csproj-Datei haben, einfügen. Eine vollständige Csproj-Beispieldatei wird weiter unten in diesem Abschnitt angezeigt.

  2. Veröffentlichen der App.

    Nachdem Sie das Programm gedebuggt und getestet haben, erstellen Sie die Dateien, die mit Ihrer App für jede Plattform bereitgestellt werden sollen, auf die sie ausgerichtet ist.

    Gehen Sie wie folgt vor, um Ihre App aus Visual Studio zu veröffentlichen:

    1. Ändern Sie die Lösungskonfiguration von "Debuggen " in " Release " auf der Symbolleiste, um eine Releaseversion (anstelle einer Debugversion) Ihrer App zu erstellen.

    2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt (nicht auf die Projektmappe), und wählen Sie "Veröffentlichen" aus.

    3. Wählen Sie auf der Registerkarte " Veröffentlichen " die Option "Veröffentlichen" aus. Visual Studio schreibt die Dateien, aus denen Ihre Anwendung besteht, in das lokale Dateisystem.

    4. Auf der Registerkarte " Veröffentlichen " wird jetzt ein einzelnes Profil " FolderProfile" angezeigt. Die Konfigurationseinstellungen des Profils werden im Abschnitt "Zusammenfassung " der Registerkarte angezeigt. Die Ziellaufzeit gibt an, welche Laufzeit veröffentlicht wurde, und der Zielspeicherort gibt an, wo die Dateien für die eigenständige Bereitstellung geschrieben wurden.

    5. Visual Studio schreibt standardmäßig alle veröffentlichten Dateien in ein einzelnes Verzeichnis. Aus Gründen der Einfachheit ist es am besten, separate Profile für jede Ziellaufzeit zu erstellen und veröffentlichte Dateien in einem plattformspezifischen Verzeichnis zu platzieren. Dazu gehört das Erstellen eines separaten Veröffentlichungsprofils für jede Zielplattform. Erstellen Sie nun die Anwendung für jede Plattform neu, indem Sie die folgenden Schritte ausführen:

      1. Wählen Sie im Dialogfeld "Veröffentlichen" die Option " Neues Profil erstellen " aus .

      2. Ändern Sie im Dialogfeld " Zielveröffentlichung auswählen" den Ordner "Ordner auswählen " in "bin\Release\PublishOutput\win-x64". Wählen Sie OK aus.

      3. Wählen Sie das neue Profil (FolderProfile1) in der Liste der Profile aus, und stellen Sie sicher, dass die Ziellaufzeit ist win-x64. Wenn dies nicht der Grund ist, wählen Sie "Einstellungen" aus. Ändern Sie im Dialogfeld "Profileinstellungen " die Ziellaufzeit , win-x64 und wählen Sie " Speichern" aus. Wählen Sie andernfalls Abbrechen aus.

      4. Wählen Sie "Veröffentlichen " aus, um Ihre App für 64-Bit-Windows 10-Plattformen zu veröffentlichen.

      5. Führen Sie die vorherigen Schritte erneut aus, um ein Profil für die osx-x64 Plattform zu erstellen. Der Zielspeicherort ist "bin\Release\PublishOutput\osx-x64", und die Ziellaufzeit lautet osx-x64. Der Name, den Visual Studio diesem Profil zuweist, ist FolderProfile2.

    Jeder Zielspeicherort enthält den vollständigen Satz von Dateien (sowohl Ihre App-Dateien als auch alle .NET Core-Dateien), die zum Starten der App erforderlich sind.

Zusammen mit den Dateien Ihrer Anwendung gibt der Veröffentlichungsprozess eine Programmdatenbankdatei (PDB) aus, die Debuginformationen zu Ihrer App enthält. Die Datei ist in erster Linie für das Debuggen von Ausnahmen nützlich. Sie können auswählen, dass sie nicht mit den Dateien Ihrer Anwendung verpackt werden soll. Sie sollten sie jedoch speichern, wenn Sie den Releasebuild Ihrer App debuggen möchten.

Stellen Sie die veröffentlichten Dateien auf beliebige Weise bereit. Sie können sie beispielsweise in einer ZIP-Datei verpacken, einen einfachen copy Befehl verwenden oder mit einem beliebigen Installationspaket ihrer Wahl bereitstellen.

Es folgt die vollständige csproj-Datei für dieses Projekt.

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

Eigenständige Bereitstellung mit Abhängigkeiten von Drittanbietern

Die Bereitstellung einer eigenständigen Bereitstellung mit einer oder mehreren Abhängigkeiten von Drittanbietern umfasst das Hinzufügen der Abhängigkeiten. Die folgenden zusätzlichen Schritte sind erforderlich, bevor Sie Ihre App erstellen können:

  1. Verwenden Sie den NuGet-Paket-Manager , um ihrem Projekt einen Verweis auf ein NuGet-Paket hinzuzufügen. und wenn das Paket noch nicht auf Ihrem System verfügbar ist, installieren Sie es. Um den Paket-Manager zu öffnen, wählen Sie "Tools>NuGet Package Manager>Manage NuGet Packages for Solution" aus.

  2. Vergewissern Sie sich, dass Ihre Abhängigkeiten von Drittanbietern (z Newtonsoft.Json. B. ) auf Ihrem System installiert sind, und installieren Sie sie, falls nicht, sie. Auf der Registerkarte "Installiert " sind NuGet-Pakete aufgeführt, die auf Ihrem System installiert sind. Wenn Newtonsoft.Json dort nicht aufgeführt ist, wählen Sie die Registerkarte "Durchsuchen " aus, und geben Sie "Newtonsoft.Json" in das Suchfeld ein. Wählen Sie Newtonsoft.Json im rechten Bereich Ihr Projekt aus, bevor Sie "Installieren" auswählen.

  3. Wenn Newtonsoft.Json sie bereits auf Ihrem System installiert ist, fügen Sie es zu Ihrem Projekt hinzu, indem Sie ihr Projekt im rechten Bereich der Registerkarte " Pakete für Lösung verwalten " auswählen.

Es folgt die vollständige csproj-Datei für dieses Projekt:

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

Wenn Sie Ihre Anwendung bereitstellen, sind alle in Ihrer App verwendeten Abhängigkeiten von Drittanbietern auch in Ihren Anwendungsdateien enthalten. Drittanbieterbibliotheken sind für das System, auf dem die App ausgeführt wird, nicht erforderlich.

Sie können nur eine eigenständige Bereitstellung mit einer Drittanbieterbibliothek auf Plattformen bereitstellen, die von dieser Bibliothek unterstützt werden. Dies ist vergleichbar mit Abhängigkeiten von Drittanbietern mit systemeigenen Abhängigkeiten in Ihrer frameworkabhängigen Bereitstellung, bei der die systemeigenen Abhängigkeiten nicht auf der Zielplattform vorhanden sind, es sei denn, sie wurden dort zuvor installiert.

Siehe auch