Erste Schritte mit .NET Core unter Windows/Linux/Mac OS unter Verwendung der Befehlszeile

In diesem Thema erfahren Sie, wie Sie plattformübergreifende Anwendungen mit .NET Core CLI-Tools auf Ihrem Computer erstellen können.

Wenn Sie mit dem Toolset der .NET Core-Befehlszeilenschnittstelle nicht vertraut sind, finden Sie entsprechende Informationen in der Übersicht über das .NET Core SDK.

Erforderliche Komponenten

Hallo Konsolenanwendung!

Sie können den Beispielcode im Repository „dotnet/docs“ auf GitHub anzeigen oder herunterladen. Anweisungen zum Herunterladen finden Sie unter Beispiele und Lernprogramme.

Öffnen Sie eine Eingabeaufforderung, und erstellen Sie einen Ordner mit dem Namen Hello. Navigieren Sie zum erstellten Ordner, und geben Sie Folgendes ein:

$ dotnet new console
$ dotnet restore
$ dotnet run

Hier eine kurze Beschreibung der Schritte:

  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. Zudem wird Program.cs erstellt. Hierbei handelt es sich um eine einfache Datei, die den Einstiegspunkt für die Anwendung enthält.

    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.

    • Das Tag OutputType gibt an, dass wir eine ausführbare Datei, also eine Konsolenanwendung, erstellen.
    • Das Tag TargetFramework gibt an, welche .NET-Implementierung verwendet werden soll. In einem komplexen Szenario können Sie mehrere Zielframeworks angeben und die Erstellung für diese in einem einzigen Vorgang vornehmen. In diesem Tutorial beschränken wir uns auf Builds für .NET Core 1.0.

    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. Der Namespace System enthält grundlegende Konstrukte, wie z.B. string, oder numerische Typen.

    Wir definieren dann einen Namespace namens Hello. Sie können diesen Namen nach Wunsch ändern. Eine Klasse namens Program wird in diesem Namespace mit einer Main-Methode definiert, welche ein Array von Zeichenfolgen als Argument verwendet. Dieses Array enthält die Liste mit Argumenten, die übergeben werden, wenn das kompilierte Programm aufgerufen wird. Dieses Array wird allerdings nicht verwendet. Die Anwendung gibt lediglich „Hello World!“ auf der Konsole aus. Später werden wir Änderungen am Code vornehmen, die dieses Argument verwenden.

  2. $ dotnet restore

    dotnet restore führt einen Aufruf in NuGet (dem Paket-Manager von .NET) aus, um die Struktur der Abhängigkeiten wiederherzustellen. 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. Die project.assets.json-Datei ist zum Kompilieren und Ausführen erforderlich.

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

  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
    Hello World!
    

    Sie können alternativ dotnet build ausführen, um den Code zu kompilieren, ohne die Konsolenanwendungen des Builds auszuführen. 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). Sie können auch Argumente für die Anwendung angeben, wie Sie später im Thema sehen werden.

    $ 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. Details finden Sie unter .NET Core-Anwendungsbereitstellung.

Erweitern des Programms

Ändern wir das Programm ein bisschen. 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.

  1. Ersetzen Sie den Inhalt der Program.cs-Datei durch den folgenden 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 die Änderungen zu kompilieren.

  3. Führen Sie das Programm aus, das einen Parameter für die App übergibt:

    $ 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! Sie können Program.cs beliebig erweitern.

Arbeiten mit mehreren Dateien

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.

  1. Fügen Sie eine neue Datei im Hello-Verzeichnis mit dem Namen FibonacciGenerator.cs durch den folgenden Code hinzu:

    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:

    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.

  4. Führen Sie Ihre App durch, indem Sie dotnet run ausführen. Nachfolgend sehen Sie die Programmausgabe:

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

Und das ist schon alles! Nun können Sie beginnen, die grundlegenden Konzepte zur Erstellung Ihrer eigene Programme zu nutzen.

Beachten Sie, dass die Befehle und die Schritte in diesem Lernprogramm zum Ausführen der Anwendung nur während der Entwicklungszeit verwendet werden. 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.

Siehe auch

Organisieren und Testen von Projekten mit .NET Core CLI-Tools