Bereitstellen von .NET Core-Apps mit Visual Studio

  • Artikel

Sie können eine .NET Core-Anwendung entweder als Framework-abhängige Bereitstellung bereitstellen, was die Binärdateien Ihrer Anwendung einschließt, jedoch von Präsenz von .NET Core auf dem Zielsystem abhängt, oder als eigenständige Bereitstellung,die jeweils Ihre Anwendung sowie .NET Core-Binärdateien einschließt. Einen Überblick über die Bereitstellung von .NET Core-Anwendungen finden Sie unter .NET Core Anwendungsbereitstellung.

Die folgenden Abschnitte zeigen, wie Sie Microsoft Visual Studio zum Erstellen der folgenden Bereitstellungen verwenden:

  • Framework-abhängige Bereitstellung
  • Framework-abhängige Bereitstellung mit Drittanbieterabhängigkeiten
  • Eigenständige Bereitstellung
  • Eigenständige Bereitstellung mit Drittanbieterabhängigkeiten

Informationen zur Verwendung von Visual Studio für die Entwicklung von .NET Core-Anwendungen finden Sie unter .NET Core-Abhängigkeiten und -Anforderungen.

Framework-abhängige Bereitstellung

Die Bereitstellung einer Framework-abhängigen Bereitstellung ohne Drittanbieter-Abhängigkeiten umfasst nur das Erstellen, Testen und Veröffentlichen der Anwendung. Ein einfaches, in C# geschriebenes Beispiel veranschaulicht den Prozess.

  1. Erstellen eines Projekts

    Wählen Sie Datei>Neu>Projekt aus. Erweitern Sie im Dialogfeld Neues Projekt die Projektkategorien Ihrer Programmiersprache (C# oder Visual Basic) im Bereich Installiert, wählen Sie .NET Core aus, und wählen Sie dann im mittleren Bereich die Vorlage Konsolenanwendung (.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. Der Benutzer wird zur Texteingabe aufgefordert, und die einzelnen Wörter, die vom Benutzer eingegeben wurden, werden angezeigt. Der reguläre Ausdruck \w+ wird verwendet, um 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 ein Debugbuild Ihrer App.

    Wählen Sie Erstellen>Projektmappe erstellen aus. Sie können auch das Debugbuild Ihrer Anwendung erstellen und ausführen, indem Sie Debuggen>Debugging starten auswählen.

  4. Stellen Sie Ihre App bereit.

    Nachdem Sie die Anwendung debuggt und getestet haben, erstellen Sie die Dateien, die mit Ihrer Anwendung bereitgestellt werden. Um eine Veröffentlichung über Visual Studio durchzuführen, tun Sie Folgendes:

    1. Ändern Sie die Projektmappenkonfiguration von Debuggen zu Freigabe auf der Symbolleiste, um eine Releaseversion (anstatt eine Debugversion) Ihrer App zu erstellen.

    2. Führen Sie auf dem Projekt (nicht in der Projektmappe) im Projektmappen-Explorer einen Rechtsklick aus, und wählen Sie Veröffentlichen aus.

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

    4. Die Registerkarte Veröffentlichen zeigt nun ein einzelnes Profil an: FolderProfile. Die Konfigurationseinstellungen des Profils werden im Abschnitt Zusammenfassung der Registerkarte gezeigt.

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

Der Veröffentlichungsprozess gibt zusammen mit den Dateien Ihrer Anwendung eine Programmdatenbankdatei (.pdb) aus, die Debuginformationen über Ihre Anwendung enthält. Die Datei ist vornehmlich für das Debuggen von Ausnahmen nützlich. Sie können sich auch dazu entschließen, sie nicht mit den Dateien Ihrer Anwendung zu packen. Jedoch sollten Sie sie für den Fall speichern, dass Sie das Releasebuild Ihrer App debuggen möchten.

Stellen Sie den vollständige Satz von Anwendungsdateien so bereit, wie Sie möchten. Sie können sie z.B. in einer ZIP-Datei verpacken, und einen einfachen copy-Befehl verwenden, oder sie mit jedem Installationspaket Ihrer Wahl bereitstellen. Sobald die Anwendung installiert ist, können Benutzer sie mithilfe des dotnet-Befehls ausführen und den Dateinamen der Anwendung bereitstellen, z.B. dotnet fdd.dll.

Das Installationsprogramm sollte zusätzlich zu den Binärdateien der Anwendung das freigegebene Framework-Installationsprogramm bündeln, oder als erforderliche Komponente im Rahmen der Anwendungsinstallation überprüfen. Die Installation des gemeinsam genutzten Frameworks erfordert Administrator-/Root-Zugriff, da es sich um eine computerweite Installation handelt.

Framework-abhängige Bereitstellung mit Drittanbieterabhängigkeiten

Die Bereitstellung einer Framework-abhängigen Bereitstellung mit mindestens einer Drittanbieterabhängigkeit erfordert, dass Abhängigkeiten für Ihr Projekt verfügbar sind. Die folgenden Schritte müssen noch durchgeführt werden, bevor Sie Ihre App erstellen können:

  1. Verwenden Sie den NuGet-Paket-Manager, um einem NuGet-Paket einen Verweis für Ihr Projekt hinzuzufügen. Falls das Paket noch nicht auf Ihrem System verfügbar ist, installieren Sie es. Wählen Sie zum Öffnen des Paket-Managers Tools>NuGet-Paket-Manager>NuGet-Pakete für Projektmappe verwalten aus.

  2. Bestätigen Sie, dass Ihre Drittanbieterabhängigkeiten (z. B. Newtonsoft.Json) auf Ihrem System installiert sind. Falls dies nicht der Fall ist, installieren Sie sie. Die Registerkarte Installiert listet NuGet-Pakete auf, die auf Ihrem System installiert sind. Wenn Newtonsoft.Json hier nicht aufgelistet ist, wählen Sie die Registerkarte Durchsuchen aus, und geben Sie „Newtonsoft.Json“ in das Suchfeld ein. Wählen Sie Newtonsoft.Json aus, und wählen Sie im rechten Bereich Ihre Projekt, bevor Sie auf Installieren klicken.

  3. Wenn Newtonsoft.Json bereits auf Ihrem System installiert ist, fügen Sie es Ihrem Projekt hinzu, indem Sie Ihr Projekt im rechten Bereich der Registerkarte Pakete für Projektmappe verwalten auswählen.

Eine frameworkabhängige Bereitstellung mit Drittanbieterabhängigkeiten ist nur so portierbar wie ihre Drittanbieterabhängigkeiten. Falls eine Drittanbieter-Bibliothek nur macOS unterstützen sollte, so wird die Anwendung nicht auf Windows-Systeme übertragbar sein. Dies kann geschehen, wenn die Drittanbieter-Abhängigkeit selbst vom nativen Code abhängt. Ein gutes Beispiel dafür ist der Kestrel-Server, der eine native Abhängigkeit unter libuv erfordert. Wenn bei dieser Art von Drittanbieter-Abhängigkeit eine FDD für eine Anwendung erstellt wird, enthält die veröffentlichte Ausgabe einen Ordner für jede Runtime-ID (RID), die die native Abhängigkeit unterstützt (und im NuGet-Paket vorhanden ist).

Eigenständige Bereitstellung mit Drittanbieterabhängigkeiten

Das Bereitstellen einer eigenständigen Bereitstellung ohne Abhängigkeiten von Drittanbietern umfasst das Erstellen des Projekts, das Ändern der CSPROJ-Datei sowie das Erstellen, Testen und Veröffentlichen der Anwendung. Ein einfaches, in C# geschriebenes Beispiel veranschaulicht den Prozess. Zunächst erstellen, codieren und testen Sie Ihr Projekt wie eine Framework-abhängige Bereitstellung:

  1. Erstellen eines Projekts

    Wählen Sie Datei>Neu>Projekt aus. Erweitern Sie im Dialogfeld Neues Projekt die Projektkategorien Ihrer Programmiersprache (C# oder Visual Basic) im Bereich Installiert, wählen Sie .NET Core aus, und wählen Sie dann im mittleren Bereich die Vorlage Konsolenanwendung (.NET Core) aus. Geben Sie im Textfeld Name einen Projektnamen ein, z.B. „SCD“, und 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 in Ihrem Editor, und ersetzen Sie den automatisch generierten Code durch den folgenden Code. Der Benutzer wird zur Texteingabe aufgefordert, und die einzelnen Wörter, die vom Benutzer eingegeben wurden, werden angezeigt. Der reguläre Ausdruck \w+ wird verwendet, um 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 Globalisierungsmodus verwenden möchten.

    Insbesondere, wenn Ihre Anwendung für Linux konzipiert ist, können Sie die Gesamtgröße Ihrer Bereitstellung reduzieren, indem Sie den invarianten Globalisierungsmodus verwenden. Der invariante Globalisierungsmodus eignet sich für Anwendungen, die nicht für den globalen Einsatz ausgelegt sind, und Formatierungskonventionen, Groß-/Kleinschreibungskonventionen, Zeichenfolgenvergleiche und Sortierreihenfolgen der invarianten Kultur verwenden können.

    Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf Ihr Projekt (nicht auf die Projektmappe), und klicken Sie auf SCD.csproj bearbeiten oder SCD.vbproj bearbeiten. Fügen Sie der Datei dann die folgenden hervorgehobenen Zeilen hinzu:

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

  <PropertyGroup>
    <TargetFramework>net6.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 Erstellen>Projektmappe erstellen aus. Sie können auch das Debugbuild Ihrer Anwendung erstellen und ausführen, indem Sie Debuggen>Debugging starten auswählen. Mit diesem Schritt können Sie beim Debuggen Probleme mit Ihrer Anwendung identifizieren, die auftreten, wenn sie auf Ihrer Hostplattform ausgeführt wird. Sie müssen dies dennoch auf jeder Zielplattform testen.

    Wenn Sie den invarianten Globalisierungsmodus aktiviert haben, stellen Sie unbedingt sicher, ob das Fehlen von kulturabhängigen Daten für die Anwendung geeignet ist.

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

Nachdem Sie das Programm debuggt und getestet haben, erstellen Sie die Dateien, die mit Ihrer App für jede Zielplattform bereitgestellt werden sollen.

Um eine Veröffentlichung Ihrer App über Visual Studio durchzuführen, tun Sie Folgendes:

  1. Definieren Sie die Zielplattformen für Ihre App.

    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 das Tag <RuntimeIdentifiers> im Abschnitt <PropertyGroup> Ihrer Datei csproj, der die Plattformen Ihrer Anwendungsziele definiert und die Runtime-ID jeder Zielplattform angibt. Sie müssen auch ein Semikolon hinzufügen, um die RIDs trennen. Sie finden eine RID-Liste im RID-Katalog.

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

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

    Das Element <RuntimeIdentifiers> kann jedem <PropertyGroup>-Element in Ihrer Datei CSPROJ hinzugefügt werden. Eine vollständige CSPROJ-Beispieldatei wird später in diesem Abschnitt angezeigt.

  2. Veröffentlichen Sie die App.

    Nachdem Sie das Programm debuggt und getestet haben, erstellen Sie die Dateien, die mit Ihrer App für jede Zielplattform bereitgestellt werden sollen.

    Um eine Veröffentlichung Ihrer App über Visual Studio durchzuführen, tun Sie Folgendes:

    1. Ändern Sie die Projektmappenkonfiguration von Debuggen zu Freigabe auf der Symbolleiste, um eine Releaseversion (anstatt eine Debugversion) Ihrer App zu erstellen.

    2. Führen Sie auf dem Projekt (nicht in der Projektmappe) im Projektmappen-Explorer einen Rechtsklick aus, und wählen Sie Veröffentlichen aus.

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

    4. Die Registerkarte Veröffentlichen zeigt nun ein einzelnes Profil an: FolderProfile. Die Konfigurationseinstellungen des Profils werden im Abschnitt Zusammenfassung der Registerkarte gezeigt. Ziellaufzeit identifiziert, welche Laufzeit veröffentlicht wurde; Zielort identifiziert, 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. Der Einfachheit halber ist es am besten, separate Profile für jede Ziellaufzeit zu erstellen und veröffentlichte Dateien in einem plattformspezifischen Verzeichnis zu platzieren. Dafür muss ein separates Veröffentlichungsprofil für jede Zielplattform erstellt werden. Erstellen Sie nun die Anwendung für jede Plattform neu, indem Sie Folgendes tun:

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

      2. Ändern Sie im Dialogfeld Veröffentlichungsziel auswählen den Speicherort 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 Ziellaufzeitwin-x64 ist. Falls nicht, wählen Sie Einstellungen aus. Ändern Sie im Dialogfeld Profileinstellungen die Ziellaufzeit in win-x64, und klicken Sie auf Speichern. 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. Arbeiten Sie erneut die vorherigen Schritte durch, um ein Profil für die osx-x64-Plattform zu erstellen. Der Zielort ist bin\Release\PublishOutput\osx-x64 und die Ziellaufzeit ist osx-x64. Der Name, den Visual Studio diesem Profil zuweist, ist FolderProfile2.

    Jedes Ziel enthält den vollständigen Dateisatz (App-Dateien und alle .NET Core-Dateien), der zum Starten Ihrer App erforderlich ist.

Der Veröffentlichungsprozess gibt zusammen mit den Dateien Ihrer Anwendung eine Programmdatenbankdatei (.pdb) aus, die Debuginformationen über Ihre Anwendung enthält. Die Datei ist vornehmlich für das Debuggen von Ausnahmen nützlich. Sie können sich auch dazu entschließen, sie nicht mit den Dateien Ihrer Anwendung zu packen. Jedoch sollten Sie sie für den Fall speichern, dass Sie das Releasebuild Ihrer App debuggen möchten.

Stellen Sie die veröffentlichen Dateien in einer beliebigen Weise bereit. Sie können sie z.B. in einer ZIP-Datei verpacken, und einen einfachen copy-Befehl verwenden, oder sie mit jedem Installationspaket Ihrer Wahl bereitstellen.

Es folgt die vollständige CSPROJ-Datei dieses Projekts:

<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 Drittanbieterabhängigkeiten

Das Bereitstellen einer eigenständigen Bereitstellung mit einer oder mehreren Drittanbieter-Abhängigkeiten umfasst das Hinzufügen der Drittanbieter-Abhängigkeit: Die folgenden Schritte müssen noch durchgeführt werden, bevor Sie Ihre App erstellen können:

  1. Verwenden Sie den NuGet-Paket-Manager, um einem NuGet-Paket einen Verweis für Ihr Projekt hinzuzufügen. Falls das Paket noch nicht auf Ihrem System verfügbar ist, installieren Sie es. Wählen Sie zum Öffnen des Paket-Managers Tools>NuGet-Paket-Manager>NuGet-Pakete für Projektmappe verwalten aus.

  2. Bestätigen Sie, dass Ihre Drittanbieterabhängigkeiten (z. B. Newtonsoft.Json) auf Ihrem System installiert sind. Falls dies nicht der Fall ist, installieren Sie sie. Die Registerkarte Installiert listet NuGet-Pakete auf, die auf Ihrem System installiert sind. Wenn Newtonsoft.Json hier nicht aufgelistet ist, wählen Sie die Registerkarte Durchsuchen aus, und geben Sie „Newtonsoft.Json“ in das Suchfeld ein. Wählen Sie Newtonsoft.Json aus, und wählen Sie im rechten Bereich Ihre Projekt, bevor Sie auf Installieren klicken.

  3. Wenn Newtonsoft.Json bereits auf Ihrem System installiert ist, fügen Sie es Ihrem Projekt hinzu, indem Sie Ihr Projekt im rechten Bereich der Registerkarte Pakete für Projektmappe verwalten auswählen.

Es folgt die vollständige CSPROJ-Datei dieses Projekts:

<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 die Drittanbieter-Abhängigkeiten, die in Ihrer Anwendung verwendet werden, auch in Ihren Anwendungsdateien enthalten. Drittanbieter-Bibliotheken müssen nicht auf dem System vorhanden sein, auf dem die Anwendung ausgeführt wird.

Eine eigenständige Bereitstellung mit einer Drittanbieterbibliothek kann nur auf von dieser Bibliothek unterstützten Plattformen bereitgestellt werden. Dies ist ähnlich, als wenn Sie über Drittanbieter-Abhängigkeiten mit nativen Abhängigkeiten in Ihrer Framework-abhängigen Bereitstellung verfügen, wobei die nativen Abhängigkeiten nicht auf der Zielplattform vorhanden sind, es sei denn, sie wurden dort zuvor installiert.

Siehe auch