Erste Schritte mit .NET Core unter Windows/Linux/Mac OS unter Verwendung der BefehlszeileGetting started with .NET Core on Windows/Linux/macOS using the command line

In diesem Thema erfahren Sie, wie Sie plattformübergreifende Anwendungen mit .NET Core CLI-Tools auf Ihrem Computer erstellen können.This topic will show you how to start developing cross-platforms apps in your machine using the .NET Core CLI tools.

Wenn Sie mit dem Toolset der .NET Core-Befehlszeilenschnittstelle nicht vertraut sind, finden Sie entsprechende Informationen in der Übersicht über das .NET Core SDK.If you're unfamiliar with the .NET Core CLI toolset, read the .NET Core SDK overview.

Erforderliche KomponentenPrerequisites

Hallo Konsolenanwendung!Hello, Console App!

Sie können den Beispielcode im Repository „dotnet/samples“ auf GitHub anzeigen oder herunterladen.You can view or download the sample code from the dotnet/samples GitHub repository. Anweisungen zum Herunterladen finden Sie unter Beispiele und Lernprogramme.For download instructions, see Samples and Tutorials.

Öffnen Sie eine Eingabeaufforderung, und erstellen Sie einen Ordner mit dem Namen Hello.Open a command prompt and create a folder named Hello. Navigieren Sie zum erstellten Ordner, und geben Sie Folgendes ein:Navigate to the folder you created and type the following:

$ dotnet new console
$ dotnet restore
$ dotnet run

Hier eine kurze Beschreibung der Schritte:Let's do a quick walkthrough:

  1. $ dotnet new console

    Mit dotnet new wird eine aktuelle Projektdatei Hello.csproj mit den Abhängigkeiten erstellt, die zum Erstellen einer Konsolen-App benötigt werden.dotnet new creates an up-to-date Hello.csproj project file with the dependencies necessary to build a console app. Zudem wird Program.cs erstellt. Hierbei handelt es sich um eine einfache Datei, die den Einstiegspunkt für die Anwendung enthält.It also creates a Program.cs, a basic file containing the entry point for the application.

    Hello.csproj:Hello.csproj:

    <Project Sdk="Microsoft.NET.Sdk">
    
      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>netcoreapp1.0</TargetFramework>
      </PropertyGroup>
    
    </Project>
    

    Die Projektdatei gibt alle Elemente an, die zum Wiederherstellen von Abhängigkeiten und erstellen des Programms erforderlich sind.The project file specifies everything that's needed to restore dependencies and build the program.

    • Das Tag OutputType gibt an, dass wir eine ausführbare Datei, also eine Konsolenanwendung, erstellen.The OutputType tag specifies that we're building an executable, in other words a console application.
    • Das Tag TargetFramework gibt an, welche .NET-Implementierung verwendet werden soll.The TargetFramework tag specifies what .NET implementation we're targeting. In einem komplexen Szenario können Sie mehrere Zielframeworks angeben und die Erstellung für diese in einem einzigen Vorgang vornehmen.In an advanced scenario, you can specify multiple target frameworks and build to all those in a single operation. In diesem Tutorial beschränken wir uns auf Builds für .NET Core 1.0.In this tutorial, we'll stick to building only for .NET Core 1.0.

    Program.cs:Program.cs:

    using System;
    
    namespace Hello
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("Hello World!");
            }
        }
    }
    

    Das Programm startet mithilfe von using System, was bedeutet, dass alles im Namespace System in den Geltungsbereich für diese Datei gebracht wird.The program starts by using System, which means "bring everything in the System namespace into scope for this file". Der Namespace System enthält grundlegende Konstrukte, wie z.B. string, oder numerische Typen.The System namespace includes basic constructs such as string, or numeric types.

    Wir definieren dann einen Namespace namens Hello.We then define a namespace called Hello. Sie können diesen Namen nach Wunsch ändern.You can change this to anything you want. Eine Klasse namens Program wird in diesem Namespace mit einer Main-Methode definiert, welche ein Array von Zeichenfolgen als Argument verwendet.A class named Program is defined within that namespace, with a Main method that takes an array of strings as its argument. Dieses Array enthält die Liste mit Argumenten, die übergeben werden, wenn das kompilierte Programm aufgerufen wird.This array contains the list of arguments passed in when the compiled program is called. Dieses Array wird allerdings nicht verwendet. Die Anwendung gibt lediglich „Hello World!“As it is, this array is not used: all the program is doing is to write "Hello World!" auf der Konsole aus.to the console. Später werden wir Änderungen am Code vornehmen, die dieses Argument verwenden.Later, we'll make changes to the code that will make use of this argument.

    Hinweis

    Ab .NET Core 2.0 müssen Sie dotnet restore nicht mehr ausführen, da der Befehl implizit von allen Befehlen, z.B. dotnet new, dotnet build und dotnet run, ausgeführt wird, die eine Wiederherstellung erfordern.Starting with .NET Core 2.0, you don't have to run dotnet restore because it's run implicitly by all commands that require a restore to occur, such as dotnet new, dotnet build and dotnet run. In bestimmten Fällen eignet sich der Befehl dennoch. Dies ist etwa bei Szenarios der Fall, in denen das Ausführen einer expliziten Wiederherstellung sinnvoll ist. Beispiele hierfür sind Continuous Integration-Builds in Visual Studio Team Services oder Buildsystemen, die den Zeitpunkt für die Wiederherstellung explizit festlegen müssen.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.

  2. $ dotnet restore

    dotnet restore führt einen Aufruf in NuGet (dem Paket-Manager von .NET) aus, um die Struktur der Abhängigkeiten wiederherzustellen.dotnet restore calls into NuGet (.NET package manager) to restore the tree of dependencies. NuGet analysiert die Hello.csproj-Datei, lädt die in der Datei angegebenen Abhängigkeiten herunter (oder ruft diese aus einem Cache auf Ihrem Computer ab) und schreibt die obj/project.assets.json-Datei.NuGet analyzes the Hello.csproj file, downloads the dependencies stated in the file (or grabs them from a cache on your machine), and writes the obj/project.assets.json file. Die project.assets.json-Datei ist zum Kompilieren und Ausführen erforderlich.The project.assets.json file is necessary to be able to compile and run.

    Bei der project.assets.json-Datei handelt es sich um eine persistente und umfassende Gruppe des Diagramms von NuGet-Abhängigkeiten und anderen Informationen, die eine Anwendung beschreiben.The project.assets.json file is a persisted and complete set of the graph of NuGet dependencies and other information describing an app. Diese Datei wird von anderen Tools wie dotnet build und dotnet run gelesen, die dadurch in die Lage versetzt werden, den Quellcode mit einer vorschriftsmäßigen Menge von NuGet-Abhängigkeiten und Bindungsauflösungen zu verarbeiten.This file is read by other tools, such as dotnet build and dotnet run, enabling them to process the source code with a correct set of NuGet dependencies and binding resolutions.

  3. $ dotnet run

    dotnet run ruft dotnet build auf, um sicherzustellen, dass die Buildziele erstellt wurden, und ruft anschließend dotnet <assembly.dll> auf, um die Zielanwendung auszuführen.dotnet run calls dotnet build to ensure that the build targets have been built, and then calls dotnet <assembly.dll> to run the target application.

    $ dotnet run
    Hello World!
    

    Sie können alternativ dotnet build ausführen, um den Code zu kompilieren, ohne die Konsolenanwendungen des Builds auszuführen.Alternatively, you can also execute dotnet build to compile the code without running the build console applications. Dies führt zu einer kompilierten Anwendung, wie einer DLL-Datei, die mit dotnet bin\Debug\netcoreapp1.0\Hello.dll unter Windows ausgeführt werden kann (verwenden Sie / für nicht-Windowssysteme).This results in a compiled application as a DLL file that can be run with dotnet bin\Debug\netcoreapp1.0\Hello.dll on Windows (use / for non-Windows systems). Sie können auch Argumente für die Anwendung angeben, wie Sie später im Thema sehen werden.You may also specify arguments to the application as you'll see later on the topic.

    $ dotnet bin\Debug\netcoreapp1.0\Hello.dll
    Hello World!
    

    In einem komplexen Szenario ist es möglich, die Anwendung als eigenständigen Satz plattformspezifischer Dateien zu erstellen, die auf einen Computer bereitgestellt und ausgeführt werden können, auf dem nicht notwendigerweise .NET Core installiert ist.As an advanced scenario, it's possible to build the application as a self-contained set of platform-specific files that can be deployed and run to a machine that doesn't necessarily have .NET Core installed. Details finden Sie unter .NET Core-Anwendungsbereitstellung.See .NET Core Application Deployment for details.

Erweitern des ProgrammsAugmenting the program

Ändern wir das Programm ein bisschen.Let's change the program a bit. Fibonacci-Zahlen sind interessant, also fügen wir sie zusätzlich zur Verwendung des Arguments für die Begrüßung der Person hinzu, die die Anwendung ausführt.Fibonacci numbers are fun, so let's add that in addition to use the argument to greet the person running the app.

  1. Ersetzen Sie den Inhalt der Program.cs-Datei durch den folgenden Code:Replace the contents of your Program.cs file with the following code:

    using System;
    
    namespace Hello
    {
        class Program
        {
            static void Main(string[] args)
            {
                if (args.Length > 0)
                {
                    Console.WriteLine($"Hello {args[0]}!");
                }
                else
                {
                    Console.WriteLine("Hello!");
                }
    
                Console.WriteLine("Fibonacci Numbers 1-15:");
    
                for (int i = 0; i < 15; i++)
                {
                    Console.WriteLine($"{i + 1}: {FibonacciNumber(i)}");
                }
            }
    
            static int FibonacciNumber(int n)
            {
                int a = 0;
                int b = 1;
                int tmp;
    
                for (int i = 0; i < n; i++)
                {
                    tmp = a;
                    a = b;
                    b += tmp;
                }
    
                return a;
            }
    
        }
    }
    
  2. Führen Sie dotnet build aus, um diese Änderungen zu kompilieren.Execute dotnet build to compile the changes.

  3. Führen Sie das Programm aus, das einen Parameter für die App übergibt:Run the program passing a parameter to the app:

    $ dotnet run -- John
    Hello John!
    Fibonacci Numbers 1-15:
    1: 0
    2: 1
    3: 1
    4: 2
    5: 3
    6: 5
    7: 8
    8: 13
    9: 21
    10: 34
    11: 55
    12: 89
    13: 144
    14: 233
    15: 377
    

Und das ist schon alles!And that's it! Sie können Program.cs beliebig erweitern.You can augment Program.cs any way you like.

Arbeiten mit mehreren DateienWorking with multiple files

Einzelne Dateien sind für einfache einmalige Programme in Ordnung, aber wenn Sie eine komplexere Anwendung erstellen, verfügen Sie wahrscheinlich über mehrere Quelldateien in Ihrem Projekt. Bauen wir auf den vorherigen Fibonacci-Werten auf und fügen wir rekursive Features hinzu.Single files are fine for simple one-off programs, but if you're building a more complex app, you're probably going to have multiple source files on your project Let's build off of the previous Fibonacci example by caching some Fibonacci values and add some recursive features.

  1. Fügen Sie eine neue Datei im Hello-Verzeichnis mit dem Namen FibonacciGenerator.cs durch den folgenden Code hinzu:Add a new file inside the Hello directory named FibonacciGenerator.cs with the following code:

    using System;
    using System.Collections.Generic;
    
    namespace Hello
    {
    	public class FibonacciGenerator
    	{
    		private Dictionary<int, int> _cache = new Dictionary<int, int>();
    		
    		private int Fib(int n) => n < 2 ? n : FibValue(n - 1) + FibValue(n - 2);
    		
    		private int FibValue(int n)
    		{
    			if (!_cache.ContainsKey(n))
    			{
    				_cache.Add(n, Fib(n));
    			}
    			
    			return _cache[n];
    		}
    		
    		public IEnumerable<int> Generate(int n)
    		{
    			for (int i = 0; i < n; i++)
    			{
    				yield return FibValue(i);
    			}
    		}
    	}
    }
    
  2. Ändern Sie die Main-Methode in Ihrer Program.cs-Datei, um die neue Klasse zu instanziieren und rufen Sie die Methode wie im folgenden Beispiel auf:Change the Main method in your Program.cs file to instantiate the new class and call its method as in the following example:

    using System;
    
    namespace Hello
    {
        class Program
        {
            static void Main(string[] args)
            {
                var generator = new FibonacciGenerator();
                foreach (var digit in generator.Generate(15))
                {
                    Console.WriteLine(digit);
                }
            }
        }
    }
    
  3. Führen Sie dotnet build aus, um diese Änderungen zu kompilieren.Execute dotnet build to compile the changes.

  4. Führen Sie Ihre App durch, indem Sie dotnet run ausführen.Run your app by executing dotnet run. Nachfolgend sehen Sie die Programmausgabe:The following shows the program output:

    0
    1
    1
    2
    3
    5
    8
    13
    21
    34
    55
    89
    144
    233
    377
    

Und das ist schon alles!And that's it! Nun können Sie beginnen, die grundlegenden Konzepte zur Erstellung Ihrer eigene Programme zu nutzen.Now, you can start using the basic concepts learned here to create your own programs.

Beachten Sie, dass die Befehle und die Schritte in diesem Lernprogramm zum Ausführen der Anwendung nur während der Entwicklungszeit verwendet werden.Note that the commands and steps shown in this tutorial to run your application are used during development time only. Nachdem Sie Ihre Anwendung bereitstellen möchten, sollten Sie einen Blick auf die verschiedenen Bereitstellungsstrategien für .NET Core-Anwendungen und den dotnet publish-Befehl werfen.Once you're ready to deploy your app, you'll want to take a look at the different deployment strategies for .NET Core apps and the dotnet publish command.

Siehe auchSee also

Organisieren und Testen von Projekten mit .NET Core CLI-ToolsOrganizing and testing projects with the .NET Core CLI tools