1. Einführung
Hast du schon mal versucht, eine Wassermelone in eine Flasche zu stopfen? Genau so fühlt sich C# jedes Mal, wenn du ihn bittest, eine Variable von einem Typ in einen anderen zu stecken. Manchmal ist das easy (eine kleine Zahl in eine große packen – wie ein Apfel in einen Koffer), manchmal muss man vorsichtig sein (Wassermelone in Flasche – da wird’s tricky).
Typumwandlung ist die Operation, einen Wert von einem Datentyp in einen anderen zu konvertieren. Das brauchst du oft, wenn du Werte verschiedener Typen addieren oder vergleichen willst oder sie an Methoden übergibst, die nur einen bestimmten Typ akzeptieren.
Im echten Programmiererleben begegnet dir das ständig: Du machst Zahlungen, berechnest Rabatte, führst physikalische Berechnungen durch oder parst zum Beispiel Zahlen, die ein User über die Tastatur eingibt (da kommt alles als String).
2. Implizite Typumwandlung (Implicit Conversion)
Was ist das?
Implizite Typumwandlung heißt, dass C# für dich entscheidet, dass man Daten gefahrlos von einem Typ in einen anderen „rüberschieben“ kann. Das läuft automatisch – du schreibst nix extra, du benutzt einfach die Werte.
- Der Compiler meckert nicht.
- Keine speziellen Befehle oder Casts nötig.
- Kein Datenverlust (naja, fast nie).
Beispiel für implizite Typumwandlung
int a = 42;
double b = a; // Implizite Umwandlung int -> double
Console.WriteLine(b); // 42 (aber jetzt ist es 42.0)
Hier wird a vom Typ int automatisch zu double, wenn es der Variable b zugewiesen wird. Es gibt keinen Datenverlust, weil alle int-Werte locker in double passen.
Hier wird a vom Typ int automatisch zu double, wenn es der Variable b zugewiesen wird. Es gibt keinen Datenverlust, weil alle int-Werte locker in double passen.
Wann funktioniert das?
- Wenn der Zieltyp breiter ist als der Quelltyp – also einen größeren Wertebereich unterstützt.
- Kein Datenverlust.
- Beispiele:
- int → long
- int → float / double
- float → double
- char → int
Noch ein Beispiel:
byte x = 100;
int y = x; // byte -> int (alle byte-Werte passen in den Wertebereich von int)
Tabelle der impliziten Umwandlungen für numerische Typen
| Von | Zu |
|---|---|
|
|
|
|
|
|
|
|
3. Explizite Typumwandlung (Explicit Conversion, Type Cast)
Wann reicht die Magie nicht?
Manchmal kann der Compiler nicht garantieren, dass die Umwandlung sicher ist, und verlangt von dir, dass du die Verantwortung übernimmst – du musst explizit sagen, dass du das Risiko kennst.
- Es kann sein, dass Daten verloren gehen.
- Das Format des Wertes kann sich ändern.
- Manchmal ist die Umwandlung gar nicht möglich – dann gibt’s einen Fehler.
Wie schreibt man eine explizite Umwandlung?
Man benutzt die Klammer-Syntax (cast):
double pi = 3.1415;
int wholePi = (int)pi; // Explizite Umwandlung double -> int
Console.WriteLine(wholePi); // 3 (Nachkommastellen werden abgeschnitten!)
Wann wird das verwendet?
- Wenn der Zieltyp schmaler ist als der Quelltyp – der Wertebereich des Ziels ist kleiner als der des Quelltyps.
- Möglicher Verlust von Nachkommastellen, Daten, Überlauf.
- Beispiele:
- double → int
- long → int
- int → byte
- Fast alle Umwandlungen zwischen inkompatiblen Typen.
4. Lass uns Beispiele anschauen
1) Verlieren wir Daten? Lass uns checken!
Implizite Umwandlung – alles cool!
int small = 25;
long big = small; // Implizite Umwandlung (int -> long)
Console.WriteLine(big); // 25
Explizite Umwandlung – gefährliche Zone!
int big = 1000;
byte small = (byte)big; // Explizite Umwandlung (int -> byte)
Console.WriteLine(small); // 232 (!), weil 1000 nicht in byte passt (0..255)
Hier ist das Ergebnis – „magische“ 232, weil 1000 % 256 == 232.
2) Mit Fließkommazahlen (double, float)
double number = 9.99;
int approximate = (int)number; // Nachkommastellen werden einfach abgeschnitten
Console.WriteLine(approximate); // 9
3) Umwandlung zwischen Ganzzahlen und Fließkommazahlen (double ↔ int)
int apples = 5;
double exactApples = apples; // int -> double (implizit)
Console.WriteLine(exactApples); // 5.0
double bananaWeight = 2.77;
int weightForReport = (int)bananaWeight; // double -> int (explizit)
Console.WriteLine(weightForReport); // 2
5. Was tun mit String-Konvertierung: Parse und Convert
Typumwandlung funktioniert nicht zwischen Zahlen und Strings! Dafür brauchst du spezielle Methoden, zum Beispiel:
string strNumber = "123";
int num = int.Parse(strNumber); // oder Convert.ToInt32(strNumber);
Aber umgekehrt (int → string) passiert das automatisch bei String-Konkatenation:
int number = 42;
string message = "Antwort: " + number; // Implizite Konvertierung int → string
6. Fehler bei der Typumwandlung
Geschichtslektion: Irgendwann hat mal jemand vergessen, den Typ explizit umzuwandeln, und die Endzahlung war 250-mal kleiner als nötig... Leute, passt auf!
Ein häufiger Fehler: Versuch, einen Typ implizit zu konvertieren, wo Daten verloren gehen könnten.
int big = 500;
byte small = big; // Compiler: "Geht nicht! Möglicher Datenverlust!"
Hier brauchst du eine explizite Umwandlung:
byte small = (byte)big; // Aber du riskierst Datenverlust!
Ein anderer beliebter Bug – Nachkommastellen vergessen:
double x = 2.9;
int y = (int)x; // y == 2, Nachkommastellen sind weg
Um mathematisch korrekt zu runden, benutze Math.Round:
int y = (int)Math.Round(x); // y == 3
7. Fallen bei der Umwandlung
- Datenverlust. Check immer, ob der Wert im erlaubten Bereich des Typs liegt. Zum Beispiel: int geht von -2 147 483 648 bis 2 147 483 647, aber byte nur 0–255.
- Rundung. Normale Umwandlung ((int)x) schneidet einfach die Nachkommastellen ab. Für korrektes Runden benutze Math.Round, Math.Floor, Math.Ceiling.
- Numerische Literale. Beachte, dass 3 / 2 1 ergibt (Ganzzahldivision), aber 3.0 / 2 schon 1.5 (double)!
- Gemischte Typ-Operationen. Wenn du z.B. int und double in einem Ausdruck mischst, ist das Ergebnis vom Typ double.
GO TO FULL VERSION