Variablen & Datentypen in C#

C# ist statisch typisiert, aber mit moderner Typ-Inferenz. Du wirst selten Typen ausschreiben muessen - aber es hilft zu wissen, was hinter den Kulissen passiert.

Variablen deklarieren

Mit explizitem Typ

int alter = 28;
string name = "Anna";
bool aktiv = true;
double preis = 19.99;

Mit var und Typ-Inferenz

var alter = 28;          // int
var name = "Anna";        // string
var aktiv = true;         // bool
var preis = 19.99;        // double

var ist kein dynamischer Typ - der Compiler leitet den Typ aus der rechten Seite ab und fixiert ihn. var name = "Anna"; name = 42; ist ein Fehler.

Konventionen

• Lokale Variablen: camelCase (nutzerName, maxWert)
• Felder & Properties: PascalCase (Name, MaxWert)
• Konstanten: PascalCase (MaxRetries)

Konstanten

const double Pi = 3.14159;
const int MaxRetries = 5;

const geht nur fuer primitive Werte - fuer alles andere nimmst du readonly:

static readonly DateTime Jetzt = DateTime.Now;

Die Standardtypen

Ganzzahlen

Typ	Groesse	Bereich
byte	8 Bit	0 bis 255
short	16 Bit	-32.768 bis 32.767
int	32 Bit	ca. -2,1 Mrd. bis 2,1 Mrd. (Standard)
long	64 Bit	sehr gross
uint	32 Bit	0 bis 4,2 Mrd. (vorzeichenlos)

Im Alltag nimmst du fast immer int und seltener long.

Fliesskomma

Typ	Genauigkeit	Bemerkung
float	~7 Stellen	Suffix f: 3.14f
double	~15 Stellen	Standard fuer Dezimal
decimal	28-29 Stellen (genau)	Fuer Geld: Suffix m: 19.99m

float  pi     = 3.14f;
double genau  = 3.14159265;
decimal preis = 19.99m; // ideal fuer Waehrungen

Boolean

bool aktiv = true;
bool fertig = false;

Character & String

char buchstabe = 'A';           // Einzelzeichen in einfachen Quotes
string name = "Anna";           // Text in doppelten Quotes

string mehrzeilig = @"Zeile 1
Zeile 2
Zeile 3";                       // Verbatim-String

string pfad = @"C:\Users\Anna"; // kein Escaping noetig

Wichtige String-Methoden:

name.Length              // 4
name.ToUpper()           // "ANNA"
name.Replace("a", "e")   // "Annex" - wait, das war irrefuehrend
name.Substring(1, 2)     // "nn"
name.StartsWith("A")     // true
name.Contains("nn")      // true

// Interpolation
var gruss = $"Hallo, {name}!";

// String.Format (aelter)
var text = string.Format("Hallo, {0}!", name);

Strings sind unveraenderlich - jede Operation liefert einen neuen String zurueck.

Value vs. Reference Types

Ein wichtiges Konzept in C#:

• Value Types (int, double, bool, char, struct): Werden direkt kopiert beim Zuweisen
• Reference Types (string, object, class, Arrays): Nur der Zeiger wird kopiert

// Value Type
int a = 5;
int b = a;
b = 10;
Console.WriteLine(a); // 5 - unveraendert

// Reference Type (Array)
int[] arr1 = { 1, 2, 3 };
int[] arr2 = arr1;
arr2[0] = 99;
Console.WriteLine(arr1[0]); // 99 - arr1 und arr2 zeigen aufs gleiche Array

Strings sind technisch Reference Types, verhalten sich aber wie Value Types - weil sie unveraenderlich sind.

Nullable Types

Value Types koennen standardmaessig nicht null sein:

int zahl = null; // FEHLER

Wenn du null zulassen willst:

int? zahl = null;        // Nullable int
DateTime? datum = null;

if (zahl.HasValue)
    Console.WriteLine(zahl.Value);

Nullable Reference Types

Mit <Nullable>enable</Nullable> in der .csproj warnt dich der Compiler bei moeglichen null-Zugriffen - auch auf Strings und Klassen:

string name = null;       // Warning
string? name = null;      // OK - explizit nullable

void Ausgeben(string n)
{
    Console.WriteLine(n.ToUpper()); // sicher, kein null erlaubt
}

Aktiviere das - es ist eines der besten C#-Features gegen NullReferenceException.

Typkonvertierung

Implizit (sicher)

int a = 5;
double b = a; // int passt in double, automatisch

Explizit (mit Cast)

double x = 3.7;
int y = (int)x; // 3 - Nachkommastelle abgeschnitten

Parse / TryParse

Von string zu einem Typ:

int alter = int.Parse("28");             // wirft Exception bei Fehler

if (int.TryParse(eingabe, out var wert)) // empfohlen
    Console.WriteLine(wert);
else
    Console.WriteLine("Ungueltige Eingabe");

double preis = double.Parse("19.99", CultureInfo.InvariantCulture);

Convert-Klasse

Flexibler als Cast:

var text = Convert.ToString(42);       // "42"
var zahl = Convert.ToInt32("42");      // 42
var kommas = Convert.ToDouble("3.14");

Arrays - kurzer Vorblick

int[] zahlen = { 1, 2, 3, 4, 5 };
string[] namen = new string[3];
namen[0] = "Anna";

Console.WriteLine(zahlen.Length); // 5
Console.WriteLine(zahlen[0]);     // 1

Fuer dynamische Listen: List<T> aus System.Collections.Generic - dazu spaeter mehr.

Zusammenfassung

• var fuer Typ-Inferenz, const/readonly fuer Konstanten
• int und double sind Standard, decimal fuer Geld
• string ist unveraenderlich, $"..." fuer Interpolation
• Value Types werden kopiert, Reference Types geteilt
• int? / string? fuer nullable Typen - aktiviere Nullable Reference Types!
• int.TryParse ist die sichere Konvertierung

Im naechsten Kapitel: Kontrollstrukturen - if, switch, Schleifen.