Arbeiten mit .NET: C-Sharp/ Grundlagen/ Datentypen/ Typumwandlungen

Typumwandlungen (engl. Cast) begegnen uns in der Programmierung relativ häufig. Meistens benutzen wir sie, um den Zugriff auf Daten unterschiedlicher Typen zu vereinfachen, indem wir sie vereinheitlichen, bevor wir mit ihnen spielen.

Implizite und explizite Typumwandlungen

Im Regelfall müssen wir die Typumwandlung explizit durchführen, müssen also ausdrücklich angeben, in welchen Datentyp wir umwandeln wollen. Nur in wenigen Fällen dürfte eine implizite Typumwandlung erfolgreich sein, bei der wir uns die ausdrückliche Angabe ersparen können. Aber schauen wir uns in Ruhe an, was sich hinter diesen kompliziert klingenden Worten wirklich verbirgt.

short s = 10;
int i = s;       // Implizite Typumwandlung

Soeben haben wir – quasi im Vorbeigehen – eine implizite Typumwandlung durchgeführt. Das war gar nicht schwer, oder? Aber geht es auch umgekehrt?

short s = 10;
int i = s;       // Implizite Typumwandlung
s = i;           // Implizite Typumwandlung --- schlägt fehl

Nein, das klappt so nicht; und das ist auch gut so. Der Compiler möchte uns nämlich davor bewahren, hier versehentlich einen Fehler zu machen. Denn was würde passieren, wenn i in einem etwas umfangreicheren Programm irgendwann nicht mehr 10, sondern beispielsweise 64.000 ist? In eine short-Variable passen, das wissen wir aus dem Kapitel Datentypen, nur Zahlen bis 32.767. Ein Datenverlust wäre die Folge; und wer, wenn nicht wir selbst, weiß, ob das wirklich beabsichtigt war? In diesem Fall nehmen wir es in Kauf und teilen das dem Compiler auch mit, indem wir ausdrücklich hinschreiben, dass wir wissen, dass es mit einem Datenverlust verbunden sein kann:

short s = 10;
int i = s;       // Implizite Typumwandlung
s = (short) i;   // Explizite Typumwandlung --- funktioniert wunderbar

Das war auch nicht wirklich schwer, oder? Okay, dann schauen wir uns mal an, was man noch so alles umwandeln kann.

Boxing und Unboxing

Im Kapitel Datentypen haben wir gelernt, dass C# zwischen Werttypen, die so heißen, weil sie die Werte direkt speichern, und Verweistypen, die so heißen, weil sie nur auf die Stelle verweisen, wo sich die Daten tatsächlich befinden, unterscheidet. Trotzdem können wir sie mit einem kleinen Kunstgriff ebenfalls ineinander umwandeln. Wenn man einen Werttyp in einen Verweistyp verpackt, wird dies Boxing (deutsch Verpacken) genannt; oder Unboxing (deutsch Auspacken), wenn ein Verweistyp wieder in einen Werttyp auspackt wird. … Und auch das klingt weit komplizierter, als es wirklich ist:

int i = 10;
object o = (object) i; // Explizite Typumwandlung,
                       // die in diesem Fall "Boxing" genannt wird

Soeben haben wir den Werttyp i „geboxt“, also in den Verweistyp o verpackt. Natürlich können wir ihn auch wieder auspacken:

int i = 10;
object o = (object) i; // Explizite Typumwandlung,
                       // die in diesem Fall "Boxing" genannt wird

i = (int) o            // Explizite Typumwandlung,
                       // die in diesem Fall "Unboxing" genannt wird 

Auch das war nicht sonderlich schwer, nicht wahr? Aber jetzt wird es schwerer, oder? Nicht wirklich. Weil diese Typumwandlungen so häufig auftreten, haben uns die Entwickler des .NET-Frameworks zusätzlich zu den oben genannten Möglichkeiten noch mit weiteren Onboard-Hilfsmitteln ausgestattet:

Die Convert-Klasse

Eigens für die Umwandlung wurde uns eine mächtige Klasse an die Hand gegeben, mit der wir völlig problemlos die meisten Basisdatentypen ineinander umwandeln können: die Convert-Klasse. Versuchen wir nun einfach einmal, das erste Beispiel mit der Convert-Klasse zu schreiben:

short s = 10;
int i = System.Convert.ToInt32( s ); // Typumwandlung mit Convert
s = System.Convert.ToInt16( i );     // Typumwandlung mit Convert

Eine andere, ebenfalls häufig benötigte Umwandlung besteht daraus, eine Zahl in Text (String) umzuwandeln:

int i = 16;
string str = System.Convert.ToString( i ); 

Doch wie sieht es umgekehrt aus? Kann man einen String auch in eine Zahl umwandeln? Ja, sicher doch. Ein Cast, egal ob explizit oder implizit, würde hier fehlschlagen. Aber mit Hilfe der Convert-Klasse geht das ganz einfach:

string str = "16";
int i = System.Convert.ToInt32( str ); // Typumwandlung mit Convert

Siehe auch

Convert-Klasse (MSDN, Microsoft)