Erste Schritte mit .NET Core unter Mac OSGetting started with .NET Core on macOS

Dieses Dokument bietet einen Überblick über die Schritte und den Workflow zum Erstellen einer .NET Core-Projektmappe für macOS.This document provides the steps and workflow to create a .NET Core solution for macOS. Erfahren Sie, wie Projekte und Unittests erstellt, die Debuggingtools verwendet und Bibliotheken von Drittanbietern über NuGet eingebunden werden.Learn how to create projects, unit tests, use the debugging tools, and incorporate third-party libraries via NuGet.

Hinweis

In diesem Artikel wird Visual Studio Code unter macOS verwendet.This article uses Visual Studio Code on macOS.

Erforderliche KomponentenPrerequisites

Installieren Sie das .NET Core SDK.Install the .NET Core SDK. Das .NET Core SDK umfasst die neueste Version von .NET Core-Framework und -Runtime.The .NET Core SDK includes the latest release of the .NET Core framework and runtime.

Installieren Sie Visual Studio Code.Install Visual Studio Code. Im Rahmen dieses Artikels installieren Sie auch Visual Studio Code-Erweiterungen, die den .NET Core-Entwicklungsprozess verbessern.During the course of this article, you also install Visual Studio Code extensions that improve the .NET Core development experience.

Installieren Sie die C#-Erweiterung für Visual Studio Code, indem Sie Visual Studio Code öffnen und F1 drücken, um die Visual Studio Code-Palette zu öffnen.Install the Visual Studio Code C# extension by opening Visual Studio Code and pressing F1 to open the Visual Studio Code palette. Geben Sie ext install ein, um die Liste mit Erweiterungen anzuzeigen.Type ext install to see the list of extensions. Wählen Sie die C#-Erweiterung aus.Select the C# extension. Starten Sie Visual Studio Code neu, um die Erweiterung zu aktivieren.Restart Visual Studio Code to activate the extension. Weitere Informationen finden Sie unter Dokumentation zur C#-Erweiterung von Visual Studio Code.For more information, see the Visual Studio Code C# Extension documentation.

Erste SchritteGetting started

In diesem Tutorial erstellen Sie drei Projekte: ein Bibliotheksprojekt, Tests für dieses Bibliotheksprojekt sowie eine Konsolenanwendung, die die Bibliothek nutzt.In this tutorial, you create three projects: a library project, tests for that library project, and a console application that makes use of the library. Sie können die Quelle für dieses Thema im Repository „dotnet/docs“ auf GitHub anzeigen oder herunterladen.You can view or download the source for this topic at the dotnet/docs repository on GitHub. Anweisungen zum Herunterladen finden Sie unter Beispiele und Lernprogramme.For download instructions, see Samples and Tutorials.

Starten Sie Visual Studio Code.Start Visual Studio Code. Drücken Sie STRG+\</kbd> (das Zeichen für das invertierte Hochkomma oder das Graviszeichen), oder wählen Sie **Anzeigen > Integriertes Terminal** aus dem Menü aus, um ein eingebettetes Terminal in Visual Studio Code zu öffnen.</span><span class="sxs-lookup"><span data-stu-id="533fe-123">Press <kbd>Ctrl</kbd>+<kbd>\\ (the backquote or backtick character) or select View > Integrated Terminal from the menu to open an embedded terminal in Visual Studio Code. Sie können noch immer eine externe Shell mit dem Explorer-Befehl In Eingabeaufforderung öffnen (In Terminal öffnen unter Mac oder Linux) öffnen, wenn Sie lieber außerhalb von Visual Studio Code arbeiten möchten.You can still open an external shell with the Explorer Open in Command Prompt command (Open in Terminal on Mac or Linux) if you prefer to work outside of Visual Studio Code.

Beginnen Sie, indem Sie eine Projektmappendatei erstellen, die als Container für mindestens ein .NET Core-Projekt dient.Begin by creating a solution file, which serves as a container for one or more .NET Core projects. Erstellen Sie im Terminal einen golden-Ordner, und öffnen Sie den Ordner.In the terminal, create a golden folder and open the folder. Dieser Ordner ist der Stamm der Projektmappe.This folder is the root of your solution. Führen Sie den dotnet new-Befehl aus, um eine neue Projektmappe, golden.sln, zu erstellen:Run the dotnet new command to create a new solution, golden.sln:

dotnet new sln

Führen Sie aus dem golden-Ordner den folgenden Befehl aus, um ein Bibliotheksprojekt zu erstellen, das zwei Dateien im library-Ordner erstellt: library.csproj and Class1.cs.From the golden folder, execute the following command to create a library project, which produces two files,library.csproj and Class1.cs, in the library folder:

dotnet new classlib -o library

Führen Sie den dotnet sln-Befehl aus, um das neu erstellte library.csproj-Projekt zur Projektmappe hinzuzufügen:Execute the dotnet sln command to add the newly created library.csproj project to the solution:

dotnet sln add library/library.csproj

Die library.csproj-Datei enthält die folgenden Informationen:The library.csproj file contains the following information:

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

  <PropertyGroup>
    <TargetFramework>netstandard1.4</TargetFramework>
  </PropertyGroup>

</Project>

Unsere Bibliotheksmethode serialisieren und deserialisieren Objekte im JSON-Format.Our library methods serialize and deserialize objects in JSON format. Um die JSON-Serialisierung und Deserialisierung zu unterstützen, fügen Sie einen Verweis zum Newtonsoft.Json-NuGet-Paket hinzu.To support JSON serialization and deserialization, add a reference to the Newtonsoft.Json NuGet package. Der dotnet add-Befehl fügt neue Elemente zu einem Projekt hinzu.The dotnet add command adds new items to a project. Um einen Verweis auf ein NuGet-Paket hinzuzufügen, führen Sie den dotnet add package-Befehl aus, und geben den Namen des Pakets an.To add a reference to a NuGet package, use the dotnet add package command and specify the name of the package:

dotnet add library package Newtonsoft.Json

Dadurch werden Newtonsoft.Json und dessen Abhängigkeiten zum Klassenbibliotheksprojekt hinzugefügt.This adds Newtonsoft.Json and its dependencies to the library project. Alternativ können Sie die library.csproj-Datei manuell bearbeiten, und den folgenden Knoten hinzuzufügen:Alternatively, manually edit the library.csproj file and add the following node:

<ItemGroup>
  <PackageReference Include="Newtonsoft.Json" Version="10.0.1" />
</ItemGroup>

Führen Sie dotnet restore , (Siehe Hinweis) das Abhängigkeiten wiederhergestellt und erstellt eine Obj Ordner innerhalb der Bibliothek mit drei Dateien, einschließlich einer project.assets.json Datei:Execute dotnet restore, (see note) which restores dependencies and creates an obj folder inside library with three files in it, including a project.assets.json file:

dotnet restore

Benennen Sie im Ordner library die Datei Class1.cs in Thing.cs um.In the library folder, rename the file Class1.cs to Thing.cs. Ersetzen Sie den Code durch Folgendes:Replace the code with the following:

using static Newtonsoft.Json.JsonConvert;

namespace Library
{
    public class Thing
    {
        public int Get(int left, int right) =>
            DeserializeObject<int>($"{left + right}");
    }
}

Die Thing-Klasse enthält eine öffentliche Methode, Get, die die Summe zweier Zahlen durch Konvertierung der Summe in eine Zeichenfolge zurückgibt, die anschließend in eine ganze Zahl serialisiert wird.The Thing class contains one public method, Get, which returns the sum of two numbers but does so by converting the sum into a string and then deserializing it into an integer. Hierbei werden verschiedene moderne C#-Features verwendet, wie etwa using static-Direktiven, Ausdruckskörpermitglieder und interpolierte Zeichenfolgen.This makes use of a number of modern C# features, such as using static directives, expression-bodied members, and interpolated strings.

Erstellen Sie die Bibliothek mithilfe des dotnet build-Befehls.Build the library with the dotnet build command. Dadurch wird eine integrierte library.dll-Datei unter golden/library/bin/Debug/netstandard1.4 erstellt.This produces a library.dll file under golden/library/bin/Debug/netstandard1.4:

dotnet build

Erstellen des TestprojektsCreate the test project

Erstellen Sie eine Testprojekt für die Bibliothek.Build a test project for the library. Erstellen Sie aus dem golden-Ordner ein neues Testprojekt:From the golden folder, create a new test project:

dotnet new xunit -o test-library

Fügen sie das Testprojekt zur Projektmappe hinzu:Add the test project to the solution:

dotnet sln add test-library/test-library.csproj

Fügen Sie der von Ihnen im letzten Abschnitt erstellten Bibliothek einen Projektverweis hinzu, damit der Compiler das Bibliotheksprojekt finden und verwenden kann.Add a project reference the library you created in the previous section so that the compiler can find and use the library project. Verwenden Sie den Befehl dotnet add reference:Use the dotnet add reference command:

dotnet add test-library/test-library.csproj reference library/library.csproj

Alternativ können Sie die test-library.csproj-Datei manuell bearbeiten, und den folgenden Knoten hinzuzufügen:Alternatively, manually edit the test-library.csproj file and add the following node:

<ItemGroup>
  <ProjectReference Include="..\library\library.csproj" />
</ItemGroup>

Nachdem Sie die Abhängigkeiten ordnungsgemäß konfiguriert haben, erstellen Sie nun die Tests für Ihre Bibliothek.Now that the dependencies have been properly configured, create the tests for your library. Öffnen Sie UnitTest1.cs, und ersetzen Sie den Inhalt durch den folgenden Code:Open UnitTest1.cs and replace its contents with the following code:

using Library;
using Xunit;

namespace TestApp
{
    public class LibraryTests
    {
        [Fact]
        public void TestThing() {
            Assert.NotEqual(42, new Thing().Get(19, 23));
        }
    }
}

Beachten Sie, dass der Wert 42 nicht 19+23 (oder 42) entspricht, wenn Sie zum ersten Mal den Komponententest (Assert.NotEqual) erstellen, was fehlschlagen wird.Note that you assert the value 42 is not equal to 19+23 (or 42) when you first create the unit test (Assert.NotEqual), which will fail. Ein wichtiger Schritt beim Erstellen von Komponententests ist die Erstellung des Tests, der zuerst einmal fehlschlägt, um seine Logik zu bestätigen.An important step in building unit tests is to create the test to fail once first to confirm its logic.

Führen Sie im golden-Ordner die folgenden Befehle aus:From the golden folder, execute the following commands:

dotnet restore 
dotnet test test-library/test-library.csproj

Diese Befehle finden rekursiv alle Projekte, deren Abhängigkeiten wiederhergestellt werden sollen, erstellen sie und aktivieren den xUnit-Textlauf, um die Tests auszuführen.These commands will recursively find all projects to restore dependencies, build them, and activate the xUnit test runner to run the tests. Der einzelne Text schlägt wie erwartet fehl.The single test fails, as you expect.

Bearbeiten Sie die Datei UnitTest1.cs, und ändern Sie die Assertion von Assert.NotEqual zu Assert.Equal.Edit the UnitTest1.cs file and change the assertion from Assert.NotEqual to Assert.Equal. Führen Sie den folgenden Befehl aus dem golden-Ordner aus, um den Test erneut auszuführen, der diesmal erfolgreich ausgeführt wird.Execute the following command from the golden folder to re-run the test, which passes this time:

dotnet test test-library/test-library.csproj

Schreiben der Konsolen-AppCreate the console app

Die Konsolen-App, die Sie mithilfe der folgenden Schritte erstellen, ist vom Bibliotheksprojekt abhängig, das Sie zuvor erstellt haben, und ruft seine Bibliotheksmethode auf, wenn es ausgeführt wird.The console app you create over the following steps takes a dependency on the library project you created earlier and calls its library method when it runs. Mithilfe dieses Entwicklungsmusters sehen Sie, wie Sie wiederverwendbare Bibliotheken für mehrere Projekte erstellen können.Using this pattern of development, you see how to create reusable libraries for multiple projects.

Erstellen Sie eine neue Konsolenanwendung aus dem golden-Ordner:Create a new console application from the golden folder:

dotnet new console -o app

Fügen Sie das Konsolen-App-Projekt zur Projektmappe hinzu:Add the console app project to the solution:

dotnet sln add app/app.csproj

Erstellen Sie die Abhängigkeit von der Bibliothek, indem Sie den dotnet add reference-Befehl ausführen:Create the dependency on the library by running the dotnet add reference command:

dotnet add app/app.csproj reference library/library.csproj

Führen Sie dotnet restore (Siehe Hinweis) zum Wiederherstellen der Abhängigkeiten der drei Projekte in der Projektmappe.Run dotnet restore (see note) to restore the dependencies of the three projects in the solution. Öffnen Sie Program.cs, und ersetzen Sie den Inhalt der Main-Methode durch diese Zeile:Open Program.cs and replace the contents of the Main method with the following line:

WriteLine($"The answer is {new Thing().Get(19, 23)}");

Fügen Sie ganz oben in der Program.cs-Datei zwei using-Direktiven hinzu:Add two using directives to the top of the Program.cs file:

using static System.Console;
using Library;

Führen Sie den folgenden dotnet run-Befehl aus, um die ausführbare Datei auszuführen, wobei die -p-Option für dotnet run das Projekt für die Hauptanwendung angibt.Execute the following dotnet run command to run the executable, where the -p option to dotnet run specifies the project for the main application. Die App erzeugt die Zeichenfolge „Die Antwort ist 42“.The app produces the string "The answer is 42".

dotnet run -p app/app.csproj

Debuggen der AnwendungDebug the application

Legen Sie bei der Anweisung WriteLine in der Main-Methode einen Haltepunkt fest.Set a breakpoint at the WriteLine statement in the Main method. Dies erreichen Sie, indem Sie entweder die F9-Taste drücken, wenn sich der Cursor auf der WriteLine-Zeile befindet, oder indem Sie auf den linken Rand der Zeile klicken, wo Sie den Haltepunkt festlegen möchten.Do this by either pressing the F9 key when the cursor is over the WriteLine line or by clicking the mouse in the left margin on the line where you want to set the breakpoint. Es erscheint ein Roter Kreis im Rand neben der Codezeile.A red circle will appear in the margin next to the line of code. Wenn der Haltepunkt erreicht ist, wird die Ausführung des Codes angehalten, bevor die Haltepunktzeile ausgeführt wird.When the breakpoint is reached, code execution will stop before the breakpoint line is executed.

Öffnen Sie die Registerkarte „Debugger“, indem Sie das Debugger-Symbol in der Visual Studio Code-Symbolleiste auswählen, Anzeigen > Debuggen aus der Menüleiste auswählen oder den Tastaturkurzbefehl STRG+UMSCHALT+D verwenden:Open the debugger tab by selecting the Debug icon in the Visual Studio Code toolbar, selecting View > Debug from the menu bar, or using the keyboard shortcut CTRL+SHIFT+D:

Visual Studio Code-Debugger

Klicken Sie auf die Schaltfläche „Wiedergabe“, um die Anwendung unter dem Debugger zu starten.Press the Play button to start the application under the debugger. Die App startet mit der Ausführung und läuft bis zum Haltepunkt, wo sie anhält.The app begins execution and runs to the breakpoint, where it stops. Führen Sie die Get-Methode schrittweise aus, und stellen Sie sicher, dass Sie die richtigen Argumente eingefügt haben.Step into the Get method and make sure that you have passed in the correct arguments. Bestätigen Sie, dass die Antwort 42 ist.Confirm that the answer is 42.

Hinweis

Starting with .NET Core 2.0, you don't have to run dotnet restore because it's run implicitly by all commands, such as dotnet build and dotnet run, that require a restore to occur. It's still a valid command in certain scenarios where doing an explicit restore makes sense, such as continuous integration builds in Visual Studio Team Services or in build systems that need to explicitly control the time at which the restore occurs.