Wichtige Mitteilung: Nach langer Wartezeit ist es heute endlich soweit! Hier geht es zur Ankündigung.

.NET

Was ist .NET

.NET ist ein kostenloses, quelloffenes und plattformübergreifendes Ökosystem, welches die Erstellung von Anwendungen auf Basis unterschiedlicher App-Modellen ermöglicht. Dabei stehen leistungsstarke Bibliotheken, Sprachen und Werkzeuge zur Verfügung, die eine beträchtliche Produktivität ermöglichen.

Der Weg zur Ausführung

Der .NET-Compiler als Bestandteil des .NET SDKs konvertiert den geschriebenen Quellcode in eine Zwischensprache .NET-Assembly, die eine systemunabhängige Ausführung ermöglicht. Die .NET-Laufzeit dient dann als Ausführungsumgebung für das kompilierte .NET-Assembly.

Sprachen

C# · Eine moderne, objektorientierte und typsichere Sprache
VB.NET · Eine bedienerfreundliche Sprache mit lesbarer Syntax
F# · Eine einfache Sprache für prägnanten, stabilen und widerstandsfähigen Code

Werkzeuge

Visual Studio
Visual Studio Code
.NET CLI

App-Modelle

.NET erlaubt das Entwickeln für Web, Mobile, Desktop und vieles mehr. Dabei können unterschiedliche App-Modelle herangezogen werden.

Relevante App-Modelle

Konsolen-App
Klassenbibliothek
ASP.NET Core Web-API
Blazor Server-App
Windows Forms-App

Erste Schritte mit .NET

Da aktuell das .NET SDK nicht direkt auf hopper zur Verfügung steht, muss zunächst mit ssh mydocker in den eigenen Docker-Container gewechselt werden. Dort ist ein Arbeiten mit der .NET-Befehlszeilenschnittstelle (.NET CLI) möglich.

$ dotnet sdk check
.NET SDKs:
Version      Status
------------------------
7.0.101      Up to date.

.NET Runtimes:
Name                          Version      Status
------------------------------------------------------
Microsoft.AspNetCore.App      7.0.1        Up to date.
Microsoft.NETCore.App         7.0.1        Up to date.


The latest versions of .NET can be installed from https://aka.ms/dotnet-core-download. For more information about .NET lifecycles, see https://aka.ms/dotnet-core-support.

Der oben angeführte Befehl listet die installierten SDKs und Laufzeitumgebungen auf, die zur Verfügung stehen. Alle .NET-Befehle beginnen mit dotnet und werden dann um passende Unterbefehle und Schalter ergänzt, die mithilfe von dotnet --help gesichtet werden können. Für den Anfang sind jedoch nur new zum Erstellen neuer .NET Projekte und Dateien und run zum Kompilieren und Ausführen des Programms von Relevanz.

Verfügbare Vorlagen untersuchen

Für das Anlegen eines neuen .NET-Projekts steht eine Auswahl an unterschiedlichen Vorlagen bereit, die wie folgt abgerufen werden können und die nachfolgende Ausgabe erzeugen:

$ dotnet new list
These templates matched your input:

Template Name                                 Short Name      Language    Tags
--------------------------------------------  --------------  ----------  --------------------------
ASP.NET Core Empty                            web             [C#],F#     Web/Empty
ASP.NET Core gRPC Service                     grpc            [C#]        Web/gRPC
ASP.NET Core Web API                          webapi          [C#],F#     Web/WebAPI
ASP.NET Core Web App                          webapp,razor    [C#]        Web/MVC/Razor Pages
ASP.NET Core Web App (Model-View-Controller)  mvc             [C#],F#     Web/MVC
ASP.NET Core with Angular                     angular         [C#]        Web/MVC/SPA
ASP.NET Core with React.js                    react           [C#]        Web/MVC/SPA
Blazor Server App                             blazorserver    [C#]        Web/Blazor
Blazor WebAssembly App                        blazorwasm      [C#]        Web/Blazor/WebAssembly/PWA
Class Library                                 classlib        [C#],F#,VB  Common/Library
Console App                                   console         [C#],F#,VB  Common/Console
dotnet gitignore file                         gitignore                   Config
Dotnet local tool manifest file               tool-manifest               Config
EditorConfig file                             editorconfig                Config
global.json file                              globaljson                  Config
MSTest Test Project                           mstest          [C#],F#,VB  Test/MSTest
MVC ViewImports                               viewimports     [C#]        Web/ASP.NET
MVC ViewStart                                 viewstart       [C#]        Web/ASP.NET
NuGet Config                                  nugetconfig                 Config
NUnit 3 Test Item                             nunit-test      [C#],F#,VB  Test/NUnit
NUnit 3 Test Project                          nunit           [C#],F#,VB  Test/NUnit
Protocol Buffer File                          proto                       Web/gRPC
Razor Class Library                           razorclasslib   [C#]        Web/Razor/Library
Razor Component                               razorcomponent  [C#]        Web/ASP.NET
Razor Page                                    page            [C#]        Web/ASP.NET
Solution File                                 sln                         Solution
Web Config                                    webconfig                   Config
Worker Service                                worker          [C#],F#     Common/Worker/Web
xUnit Test Project                            xunit           [C#],F#,VB  Test/xUnit

Hinweis: In vorherigen Versionen der .NET CLI wird der Befehl dotnet new --list verwendet.

Die Auflistung beinhaltet von jeder Vorlage den Namen, einen Kurznamen, die für diese Vorlage zur Verfügung stehenden Sprachen und Tags, die dem Filtern nach Vorlagen dienen. Außerdem wird mit den getschinkten Klammern die standardmäßig ausgewählte Sprachsyntax gekennzeichnet, die unkompliziert mit dem Schalter -lang bzw. --language gewechselt werden kann. Für das eigentliche Erstellen eines .NET-Projektes ist die Nutzung der Kurznamen vorgesehen.

Arbeitsumgebung vorbereiten

Vor der Erstellung des ersten Projektes sollte zuvor das eigene Arbeitsverzeichnis entsprechend vorbereitet werden. Zu diesem Zweck kann ein Ordner dotnet hinzugefügt werden, welcher zukünftig die persönlichen .NET-Projekte beinhalten soll. Nachfolgend wird darin ein weiteres Verzeichnis beginnend mit einem Großbuchstaben namens HelloWorld für das erste Programm angelegt und für weitere Aktionen in eben dieses gewechselt.

$ mkdir -p dotnet/HelloWorld
$ cd dotnet/HelloWorld

Die erste .NET-App

Zum Verstehen der Grundlagen von .NET sollte möglichst ein leicht verständliches App-Modell für die ersten Schritte selektiert werden. Eine Konsolen-App (bzw. Console App) eignet sich durch die Einfachheit und übersichtliche Projektstruktur für eben dieses Vorhaben ideal. Die Konsolenanwendung ist natürlich ebenfalls Teil der verfügbaren Vorlagen und ist im nachfolgenden Ausschnitt hervorgehoben.

$ dotnet new list
These templates matched your input:
                
Template Name                                 Short Name      Language    Tags
--------------------------------------------  --------------  ----------  --------------------------
ASP.NET Core Empty                            web             [C#],F#     Web/Empty
...
Blazor WebAssembly App                        blazorwasm      [C#]        Web/Blazor/WebAssembly/PWA
Class Library                                 classlib        [C#],F#,VB  Common/Library
Console App                                   console         [C#],F#,VB  Common/Console
dotnet gitignore file                         gitignore                   Config
Dotnet local tool manifest file               tool-manifest               Config
...
Worker Service                                worker          [C#],F#     Common/Worker/Web
xUnit Test Project                            xunit           [C#],F#,VB  Test/xUnit

Die Vorlage ist für alle der drei .NET-Sprachen verfügbar und trägt den Kurznamen console. Der Unterbefehl new erlaubt das Anlegen eines neuen Projektes auf Basis einer gewünschten Vorlage. Daher muss zum Erstellen einer Konsolen-App lediglich der Kurzname console an den Befehl angefügt werden.

$ dotnet new console
The template "Console App" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on /home/docker-linkreh/dotnet/HelloWorld/HelloWorld.csproj...
  Determining projects to restore...
  Restored /home/docker-linkreh/dotnet/HelloWorld/HelloWorld.csproj (in 161 ms).
Restore succeeded.

Mit dem Ausführen des vollständigen Befehls werden alle relevanten Bestandteile initialisiert.

Untersuchen der Projektstruktur

Die Elemente der Arbeitsstruktur eines neuen .NET-Projektes können mit dem Befehl tree bequem nachvollzogen werden. Je nach Projektvorlage und App-Modell ergeben sich unterschiedliche Dateien und andere Inhalte.

$ tree
.
├── HelloWorld.csproj
├── obj
│   ├── HelloWorld.csproj.nuget.dgspec.json
│   ├── HelloWorld.csproj.nuget.g.props
│   ├── HelloWorld.csproj.nuget.g.targets
│   ├── project.assets.json
│   └── project.nuget.cache
└── Program.cs

1 directory, 7 files

Die vielseitigen Projektvorlagen sorgen für einen angenehmen Einstieg mit sinnvollen Verweisen und passenden Beispielen. Eine Konsolen-Anwendung ist dahingehend jedoch recht kompakt.

Code verstehen

Die Datei Program.cs enthält die Anweisungen, welche beim Ausführen des Programms nacheinander abgearbeitet werden sollen:

// See https://aka.ms/new-console-template for more information
Console.WriteLine("Hello, World!");

In diesem Beispiel wird lediglich die Zeichenkette Hello, World! auf der Konsole ausgegeben. Dies kann durch das Ausführen der Konsolen-App nachgewiesen werden.

App ausführen

Der unten stehende Befehl baut das Projekt mit allen Abhängigkeiten und führt es im Anschluss aus:

$ dotnet run
Hello, World!

Das Kompilieren und das Starten der Anwendung kann auch getrennt stattfinden. Dazu kann mit dotnet build das Projekt kompiliert werden und danach mit dotnet run --no-build ausgeführt werden.

Weiterführende Schritte

Damit der Ablauf und das Verhalten der Anwendung angepasst werden kann, empfiehlt es sich nun mindestens eine der .NET-Sprachen zu lernen.