Erste Schritte mit .NET Core unter Windows/Linux/macOS unter Verwendung der BefehlszeileGet 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 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>netcoreapp2.2</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 2.1.In this tutorial, we'll stick to building only for .NET Core 2.1.

    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 SDK 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 SDK, 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 Azure DevOps 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 Azure DevOps Services or in build systems that need to explicitly control the time at which the restore occurs.

    dotnet new ruft dotnet restore implizit auf.dotnet new calls dotnet restore implicitly. 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 definierten Abhängigkeiten herunter (oder ruft diese aus einem Cache auf Ihrem Computer ab) und schreibt die obj/project.assets.json-Datei, die zum Kompilieren und Ausführen des Beispiels erforderlich ist.NuGet analyzes the Hello.csproj file, downloads the dependencies defined in the file (or grabs them from a cache on your machine), and writes the obj/project.assets.json file, which is necessary to compile and run the sample.

    Wichtig

    Wenn Sie eine .NET Core 1.x-Version des SDKs verwenden, müssen Sie dotnet restore nach dem Aufrufen von dotnet new selbst aufrufen.If you're using a .NET Core 1.x version of the SDK, you'll have to call dotnet restore yourself after calling dotnet new.

  2. 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\netcoreapp2.1\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\netcoreapp2.1\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\netcoreapp2.1\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 eignen sich gut für einfache einmalige Programme, aber wenn Sie eine komplexere App erstellen, verfügen Sie wahrscheinlich über mehrere Quelldateien in Ihrem Projekt.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. Wir bauen dazu auf dem vorherigen Fibonacci-Beispiel auf, indem wir Fibonacci-Werte zwischenspeichern und einige rekursive Features hinzufügen.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:

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

Veröffentlichen der AppPublish your app

Sobald Sie bereit sind, Ihre App zu verteilen, führen Sie den Befehl dotnet publish aus, um den Ordner publish unter bin\debug\netcoreapp2.1\publish\ zu erzeugen (verwenden Sie für Nicht-Windows-Systeme /).Once you're ready to distribute your app, use the dotnet publish command to generate the publish folder at bin\debug\netcoreapp2.1\publish\ (use / for non-Windows systems). Sie können den Inhalt des Ordners publish auf andere Plattformen verteilen, sofern auf diesen bereits die .NET-Laufzeit installiert ist.You can distribute the contents of the publish folder to other platforms as long as they've already installed the dotnet runtime.

Sie können Ihre veröffentlichte App mit dem Befehl dotnet ausführen:You can run your published app with the dotnet command:

$ dotnet bin\Debug\netcoreapp2.1\publish\Hello.dll
Hello World!

SchlussbemerkungConclusion

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.

Siehe auchSee also