> ## Documentation Index
> Fetch the complete documentation index at: https://homelab.amylify.de/llms.txt
> Use this file to discover all available pages before exploring further.
# 4.2.1 Einstieg & Hello World
> Das .NET SDK installieren, das erste C#-Projekt anlegen und den Aufbau eines Programms verstehen.
In diesem Kapitel richtest du alles ein und startest dein erstes Programm. Danach verstehst du, was die einzelnen Teile eines C#-Programms tun.
***
## .NET SDK installieren
**1. SDK installieren**
Öffne ein Terminal (PowerShell) und installiere das aktuelle SDK mit dem Windows-Paketmanager:
```powershell theme={"dark"}
winget install Microsoft.DotNet.SDK.10
```
Alternativ gibt es auf [dotnet.microsoft.com/download](https://dotnet.microsoft.com/download) einen Installer. Visual Studio bringt sein eigenes SDK mit.
**2. Installation prüfen**
Öffne danach ein **neues** Terminal, damit der Pfad geladen wird:
```powershell theme={"dark"}
dotnet --version
dotnet --list-sdks
```
Wird eine Versionsnummer wie `10.0.x` angezeigt, ist alles bereit.
**3. Editor wählen**
> [tab] Visual Studio Code
>
> Installiere die Erweiterung **C# Dev Kit**. Sie nutzt das bereits installierte SDK und bringt IntelliSense und Debugger mit.
> [tab] Visual Studio
>
> Wähle im Installer die Workload **.NET-Desktopentwicklung**. Visual Studio installiert sein eigenes SDK.
***
## Erstes Projekt anlegen
Alles läuft über die **.NET CLI**, das Kommandozeilenprogramm `dotnet`:
```powershell theme={"dark"}
dotnet new console -n HalloWelt
cd HalloWelt
dotnet run
```
| Befehl | Wirkung |
| :- | :- |
| `dotnet new console -n HalloWelt` | Legt ein neues Konsolenprojekt im Ordner `HalloWelt` an |
| `dotnet run` | Kompiliert und startet das Programm in einem Schritt |
| `dotnet build` | Kompiliert nur, ohne zu starten |
Die Konsole zeigt jetzt `Hello, World!`. Das ist bereits ein vollständiges Programm.
### Das Projekt im Überblick
**HalloWelt**
**HalloWelt.csproj**
**Program.cs**
**bin**
**obj**
| Datei oder Ordner | Bedeutung |
| :- | :- |
| `Program.cs` | Dein Code. Hier beginnt das Programm |
| `HalloWelt.csproj` | Projektdatei mit Einstellungen wie der Zielversion |
| `bin/` | Das fertig kompilierte Programm |
| `obj/` | Zwischenergebnisse des Compilers, ignorierbar |
Die Projektdatei einer neuen Konsolen-App sieht so aus:
```xml HalloWelt.csproj theme={"dark"}
Exe
net10.0
enable
enable
```
> [!NOTE]
>
> `ImplicitUsings` importiert häufig gebrauchte Namespaces wie `System` automatisch. `Nullable` aktiviert Warnungen, wenn ein Wert unerwartet `null` sein könnte.
***
## Hello World
Zwei gleichwertige Schreibweisen. Beide erzeugen dasselbe Programm.
> [tab] Top-Level-Anweisungen
>
> Die moderne Standardform. Der Code steht direkt in der Datei:
>
> ```csharp Program.cs theme={"dark"}
> Console.WriteLine("Hello, World!");
> ```
> [tab] Klassisch mit Main
>
> Die ausführliche Form mit Klasse und Einstiegsmethode. Sie begegnet dir in älteren Beispielen und größeren Projekten:
>
> ```csharp Program.cs theme={"dark"}
> namespace HalloWelt;
>
> class Program
> {
> static void Main(string[] args)
> {
> Console.WriteLine("Hello, World!");
> }
> }
> ```
> [tab] Eine einzelne Datei
>
> Ab C# 14 und .NET 10 läuft auch eine einzelne `.cs`-Datei ganz ohne Projektdatei. Praktisch für kleine Tests:
>
> ```csharp hallo.cs theme={"dark"}
> Console.WriteLine("Hello, World!");
> ```
>
> ```powershell theme={"dark"}
> dotnet run hallo.cs
> ```
> [!NOTE]
>
> Pro Projekt darf nur **eine** Datei Top-Level-Anweisungen enthalten. Der Einstiegspunkt ist die erste Zeile dieser Datei.
***
## Bausteine eines Programms
Auch bei der klassischen Form ist der Aufbau immer gleich:
| Baustein | Bedeutung |
| :- | :- |
| `using` | Macht Namespaces verfügbar, zum Beispiel `using System;` für `Console` |
| `namespace` | Gruppiert zusammengehörigen Code, ähnlich einem Ordner |
| `class` | Behälter für Daten und Methoden |
| `Main` | Einstiegspunkt: Hier startet die Ausführung |
| Anweisung | Ein einzelner Befehl, endet mit `;` |
### Ausdruck und Anweisung
Zwei Begriffe, die dir überall begegnen:
* Ein **Ausdruck** ergibt einen Wert, zum Beispiel `3 + 4` oder `Math.Max(a, b)`.
* Eine **Anweisung** führt etwas aus und endet meist mit einem Semikolon, zum Beispiel `int x = 5;`.
```csharp theme={"dark"}
int summe = 3 + 4; // Anweisung, enthält den Ausdruck 3 + 4
Console.WriteLine(summe); // Anweisung (Methodenaufruf)
```
***
## Kommentare
```csharp theme={"dark"}
// Einzeiliger Kommentar
/*
Mehrzeiliger
Kommentar
*/
/// Dokumentationskommentar, erscheint in der IntelliSense.
```
Kommentare werden nicht ausgeführt. Sie erklären, **warum** etwas so gemacht wird, nicht was die Zeile tut.
***
## Die Syntax-Grundregeln
> [card] Semikolon
>
> Jede Anweisung endet mit `;`. Blöcke in `{ }` brauchen keins.
> [card] Groß- und Kleinschreibung
>
> `Console` ist nicht `console`. C# unterscheidet streng.
> [card] Blöcke
>
> `{` öffnet, `}` schließt. Alles dazwischen gehört zusammen.
> [card] Einrückung
>
> Dem Compiler egal, aber wichtig für die Lesbarkeit. Vier Leerzeichen pro Ebene.
### Typische Anfängerfehler
| Fehler | Beispiel | Lösung |
| :- | :- | :- |
| Semikolon vergessen | `int x = 5` | `int x = 5;` |
| Klammer nicht geschlossen | `if (x > 1) { ...` | Jedes `{` braucht ein `}` |
| Falsche Schreibweise | `console.writeline()` | `Console.WriteLine()` |
| Falsche Anführungszeichen | `'Hallo'` | Text in `"Hallo"`, einzelne Zeichen in `'A'` |
> [!TIP]
>
> Beim Fehlermeldungen-Lesen immer mit dem **ersten** Fehler beginnen. Oft lösen sich die folgenden von selbst, wenn ein fehlendes Semikolon ergänzt wird.
***
## Nächster Schritt
> [card] [4.2.2 Variablen & Datentypen](https://homelab.amylify.de/documentation/code/csharp/grundlagen.md)
>
> Daten speichern, rechnen und Eingaben einlesen.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.