> ## 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.2 Variablen & Datentypen

> Variablen, Datentypen, Operatoren, Strings, Umwandlung und Ein- und Ausgabe in C#.

Programme verarbeiten Daten. Dieses Kapitel zeigt, wie du Daten speicherst, damit rechnest, Text bearbeitest und Eingaben einliest.

***

## Variablen

Eine **Variable** ist ein benannter Speicherplatz mit einem festen Typ. Die Grundform ist immer `Typ name = Wert;`.

```csharp theme={"dark"}
int alter = 20;           // deklarieren und direkt einen Wert zuweisen
string name = "Mira";
double groesse = 1.72;

alter = 21;               // Wert später ändern
```

C# ist **stark typisiert**: Eine `int`-Variable kann nie Text aufnehmen, und der Compiler meldet solche Fehler schon vor dem Start.

### var und const

```csharp theme={"dark"}
var anzahl = 10;          // der Compiler erkennt: int
var titel = "C#";         // string

const double Pi = 3.14159;   // Konstante, danach nicht mehr änderbar
```

> [!TIP]
>
> `var` spart Schreibarbeit, wenn der Typ rechts offensichtlich ist (`var liste = new List<string>();`). Der Typ ist trotzdem fest, es ist keine dynamische Variable.

***

## Datentypen

### Die wichtigsten Typen

| Typ | Inhalt | Beispiel |
| :- | :- | :- |
| `int` | Ganze Zahl (32 Bit) | `int punkte = 42;` |
| `long` | Große ganze Zahl (64 Bit) | `long einwohner = 8_000_000_000L;` |
| `double` | Kommazahl, Standard für Rechnungen | `double preis = 9.99;` |
| `float` | Kommazahl, weniger genau | `float temp = 36.6f;` |
| `decimal` | Kommazahl mit hoher Genauigkeit, für Geld | `decimal betrag = 19.99m;` |
| `bool` | Wahrheitswert | `bool aktiv = true;` |
| `char` | Ein einzelnes Zeichen | `char buchstabe = 'A';` |
| `string` | Text | `string gruss = "Hallo";` |

> [!NOTE]
>
> Die Endungen sind wichtig: `f` für `float`, `m` für `decimal`, `L` für `long`. Ohne Endung ist eine Kommazahl immer ein `double`. Mit `_` lassen sich lange Zahlen lesbar trennen.

### Wertebereiche ganzer Zahlen

| Typ | Größe | Bereich |
| :- | :- | :- |
| `byte` | 8 Bit | 0 bis 255 |
| `short` | 16 Bit | -32.768 bis 32.767 |
| `int` | 32 Bit | etwa -2,1 Mrd. bis 2,1 Mrd. |
| `long` | 64 Bit | etwa ±9,2 Trillionen |

Jeder Typ hat `MinValue` und `MaxValue`, zum Beispiel `int.MaxValue`. Läuft ein Wert über, geht es ohne Fehlermeldung auf der anderen Seite des Bereichs weiter. Für sehr große Zahlen gibt es `System.Numerics.BigInteger`.

### Wert- und Referenztypen

| | Werttypen | Referenztypen |
| :- | :- | :- |
| **Beispiele** | `int`, `double`, `bool`, `char`, `struct`, `enum` | `string`, `class`, Arrays, `List<T>` |
| **Zuweisung** | Der Wert wird **kopiert** | Beide Variablen zeigen auf **dasselbe Objekt** |
| **Änderung** | Betrifft nur die eine Variable | Ist über beide Variablen sichtbar |

```csharp theme={"dark"}
int a = 5;
int b = a;     // Kopie
b = 10;        // a bleibt 5

var liste1 = new List<int> { 1, 2, 3 };
var liste2 = liste1;   // gleiche Liste, keine Kopie
liste2.Add(4);         // liste1 enthält jetzt auch die 4
```

***

## Operatoren

| Gruppe | Operatoren | Beispiel |
| :- | :- | :- |
| Rechnen | `+` `-` `*` `/` `%` | `10 % 3` ergibt `1` (Rest) |
| Vergleichen | `==` `!=` `<` `>` `<=` `>=` | `alter >= 18` |
| Logik | `&&` (und), `\|\|` (oder), `!` (nicht) | `alter >= 18 && hatKarte` |
| Zuweisen | `=` `+=` `-=` `*=` `/=` | `punkte += 5;` |
| Zählen | `++` `--` | `zaehler++;` |

> [!WARNING]
>
> **Ganzzahldivision:** Teilst du zwei `int`-Werte, ist auch das Ergebnis ein `int`. Die Nachkommastellen fallen weg.
>
> ```csharp theme={"dark"}
> Console.WriteLine(5 / 2);     // 2   (nicht 2.5)
> Console.WriteLine(5.0 / 2);   // 2.5
> Console.WriteLine(5 / 2.0);   // 2.5
> ```

Für Berechnungen gibt es die Klasse `Math`:

```csharp theme={"dark"}
Math.Sqrt(16);        // 4
Math.Pow(2, 10);      // 1024
Math.Round(3.14159, 2); // 3,14
Math.Abs(-7);         // 7
Math.Max(3, 8);       // 8
```

***

## Strings

Ein `string` ist eine unveränderliche Folge von Zeichen. Es gibt mehrere Schreibweisen:

```csharp theme={"dark"}
string name = "Mira";

string a = "Hallo " + name;                   // Verkettung
string b = $"Hallo {name}, du bist {2026 - 2000}.";  // Interpolation (empfohlen)
string c = @"C:\Users\Mira\Dokumente";        // wörtlich: Backslash bleibt Backslash
string d = "Zeile 1\nZeile 2";                // \n = Zeilenumbruch
```

### Häufige String-Methoden

| Methode | Wirkung | Ergebnis |
| :- | :- | :- |
| `text.Length` | Anzahl der Zeichen | `5` bei `"Hallo"` |
| `text.ToUpper()` / `ToLower()` | Groß- oder Kleinschreibung | `"HALLO"` |
| `text.Trim()` | Leerzeichen am Rand entfernen | `"Hi"` aus `"  Hi "` |
| `text.Contains("al")` | Enthält Teilstring? | `true` |
| `text.StartsWith("Ha")` | Beginnt mit? | `true` |
| `text.Replace("a", "o")` | Ersetzen | `"Hollo"` |
| `text.Substring(1, 3)` | Teilstück ab Position, Länge | `"all"` |
| `text.Split(',')` | In ein Array zerlegen | `["a", "b"]` aus `"a,b"` |
| `string.IsNullOrWhiteSpace(t)` | Leer oder nur Leerzeichen? | `true` / `false` |

### Zahlen formatieren

In `{ }` kann hinter einem Doppelpunkt ein Format stehen:

```csharp theme={"dark"}
double preis = 1234.5;
Console.WriteLine($"{preis:F2}");   // 1234,50   (2 Nachkommastellen)
Console.WriteLine($"{preis:N0}");   // 1.235     (Tausenderpunkt)
Console.WriteLine($"{preis:C}");    // 1.234,50 € (Währung)
Console.WriteLine($"{0.256:P0}");   // 26 %      (Prozent)
```

> [!NOTE]
>
> Die Ausgabe richtet sich nach den Spracheinstellungen des Computers. Auf einem deutschen System erscheinen Komma und Punkt wie oben.

***

## Umwandlung von Typen

### Automatisch (implizit)

Passt der Wert garantiert hinein, wandelt C# von selbst um, zum Beispiel von klein nach groß: `int` → `long` → `double`.

```csharp theme={"dark"}
int i = 7;
double d = i;     // 7.0, automatisch
```

### Erzwungen (explizit, Cast)

Kann Information verloren gehen, musst du es selbst bestätigen:

```csharp theme={"dark"}
double d = 9.99;
int i = (int)d;   // 9 (abgeschnitten, nicht gerundet!)
```

### Text in Zahl umwandeln

`Console.ReadLine()` liefert immer Text. Für Zahlen gibt es drei Wege:

> [tab] TryParse (empfohlen)
>
> Stürzt bei falscher Eingabe nicht ab, sondern liefert `false`:
>
> ```csharp theme={"dark"}
> Console.Write("Zahl eingeben: ");
> string? eingabe = Console.ReadLine();
>
> if (int.TryParse(eingabe, out int zahl))
> {
>     Console.WriteLine($"Doppelt: {zahl * 2}");
> }
> else
> {
>     Console.WriteLine("Das war keine ganze Zahl.");
> }
> ```

> [tab] Parse
>
> Kürzer, löst bei falscher Eingabe aber eine `FormatException` aus:
>
> ```csharp theme={"dark"}
> int zahl = int.Parse("42");
> double kommazahl = double.Parse("3,14");
> ```

> [tab] Convert
>
> Wandelt zwischen vielen Typen um. Bei `null` liefert `Convert.ToInt32` eine `0`:
>
> ```csharp theme={"dark"}
> int zahl = Convert.ToInt32("42");
> string text = Convert.ToString(42);
> ```

> [!TIP]
>
> Bei Benutzereingaben immer **`TryParse`** verwenden. Eingaben sind nie vorhersehbar.

***

## Ein- und Ausgabe

```csharp theme={"dark"}
Console.WriteLine("Mit Zeilenumbruch");
Console.Write("Ohne Zeilenumbruch");

string? eingabe = Console.ReadLine();   // liest eine Zeile Text
ConsoleKeyInfo taste = Console.ReadKey(); // wartet auf einen Tastendruck
```

### EVA-Prinzip

Fast jedes Programm folgt dem Muster **E**ingabe → **V**erarbeitung → **A**usgabe:

```csharp Begruessung theme={"dark"}
// Eingabe
Console.Write("Wie heißt du? ");
string? name = Console.ReadLine();

Console.Write("Wie alt bist du? ");
int.TryParse(Console.ReadLine(), out int alter);

// Verarbeitung
int naechstesJahr = alter + 1;

// Ausgabe
Console.WriteLine($"Hallo {name}! Nächstes Jahr wirst du {naechstesJahr}.");
```

***

## Null und Nullable

`null` bedeutet "kein Wert". Mit aktivierter Nullable-Prüfung (Standard in neuen Projekten) warnt der Compiler, wenn ein Wert `null` sein könnte.

```csharp theme={"dark"}
string? eingabe = Console.ReadLine();   // das ? erlaubt null

int laenge = eingabe?.Length ?? 0;      // ?. und ??
```

| Operator | Bedeutung | Beispiel |
| :- | :- | :- |
| `?` hinter dem Typ | Wert darf `null` sein | `string? name` |
| `?.` | Nur zugreifen, wenn nicht `null` | `name?.Length` |
| `??` | Ersatzwert, wenn `null` | `name ?? "Unbekannt"` |
| `??=` | Zuweisen, wenn noch `null` | `name ??= "Gast";` |

***

## Namenskonventionen

Der Compiler erzwingt sie nicht, aber alle .NET-Projekte halten sich daran:

| Element | Schreibweise | Beispiel |
| :- | :- | :- |
| Klassen, Methoden, Properties | `PascalCase` | `Kunde`, `BerechneSumme()` |
| Lokale Variablen, Parameter | `camelCase` | `gesamtPreis` |
| Private Felder | `_camelCase` | `_kontostand` |
| Konstanten | `PascalCase` | `MaxVersuche` |
| Interfaces | `I` + `PascalCase` | `IDrucker` |

Namen dürfen Buchstaben, Ziffern und `_` enthalten, aber nicht mit einer Ziffer beginnen und kein Schlüsselwort sein. Wähle beschreibende Namen: `gesamtPreis` ist besser als `x`.

***

## Weiter

> [card] [4.2.3 Kontrollfluss](https://homelab.amylify.de/documentation/code/csharp/kontrollfluss.md)
>
> Entscheidungen treffen und Code wiederholen.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.