4.2.2 Variablen & Datentypen

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

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

var anzahl = 10;          // der Compiler erkennt: int
var titel = "C#";         // string

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

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";`

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

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++;`

Ganzzahldivision: Teilst du zwei int-Werte, ist auch das Ergebnis ein int. Die Nachkommastellen fallen weg.

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:

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:

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:

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)

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.

int i = 7;
double d = i;     // 7.0, automatisch

Erzwungen (explizit, Cast)

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

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:

TryParse (empfohlen)
Parse
Convert

Stürzt bei falscher Eingabe nicht ab, sondern liefert false:

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.");
}

Kürzer, löst bei falscher Eingabe aber eine FormatException aus:

int zahl = int.Parse("42");
double kommazahl = double.Parse("3,14");

Wandelt zwischen vielen Typen um. Bei null liefert Convert.ToInt32 eine 0:

int zahl = Convert.ToInt32("42");
string text = Convert.ToString(42);

Bei Benutzereingaben immer TryParse verwenden. Eingaben sind nie vorhersehbar.

Ein- und Ausgabe

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 Eingabe → Verarbeitung → Ausgabe:

Begruessung

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

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

4.2.3 Kontrollfluss

Entscheidungen treffen und Code wiederholen.

Getting Started

Documentation

4.2.2 Variablen & Datentypen

Variablen

var und const

Datentypen

Die wichtigsten Typen

Wertebereiche ganzer Zahlen

Wert- und Referenztypen

Operatoren

Strings

Häufige String-Methoden

Zahlen formatieren

Umwandlung von Typen

Automatisch (implizit)

Erzwungen (explizit, Cast)

Text in Zahl umwandeln

Ein- und Ausgabe

EVA-Prinzip

Null und Nullable

Namenskonventionen

Weiter

4.2.3 Kontrollfluss

​Variablen

​var und const

​Datentypen

​Die wichtigsten Typen

​Wertebereiche ganzer Zahlen

​Wert- und Referenztypen

​Operatoren

​Strings

​Häufige String-Methoden

​Zahlen formatieren

​Umwandlung von Typen

​Automatisch (implizit)

​Erzwungen (explizit, Cast)

​Text in Zahl umwandeln

​Ein- und Ausgabe

​EVA-Prinzip

​Null und Nullable

​Namenskonventionen

​Weiter

4.2.3 Kontrollfluss

Variablen

var und const

Datentypen

Die wichtigsten Typen

Wertebereiche ganzer Zahlen

Wert- und Referenztypen

Operatoren

Strings

Häufige String-Methoden

Zahlen formatieren

Umwandlung von Typen

Automatisch (implizit)

Erzwungen (explizit, Cast)

Text in Zahl umwandeln

Ein- und Ausgabe

EVA-Prinzip

Null und Nullable

Namenskonventionen

Weiter