C# Academy · Lektion

Implizite und explizite Konvertierungen

Konvertieren Sie sicher zwischen kompatiblen Typen.

Implizite und explizite Konvertierungen ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Zwischen Typen konvertieren

C# kann einen numerischen Typ in einen anderen konvertieren. Einige Konvertierungen erfolgen automatisch (implizit), während andere einen expliziten Cast erfordern.

using System;

class Program
{
    static void Main()
    {
        int i = 10;
        double d = i;       // implicit
        int back = (int)d;   // explicit
        Console.WriteLine(d + ", " + back);
    }
}

Implizite (erweiternde) Konvertierungen

Eine implizite Konvertierung ist zulässig, wenn keine Daten verloren gehen können, etwa von int zu long oder von int zu double. Ein Cast ist nicht erforderlich.

using System;

class Program
{
    static void Main()
    {
        int i = 42;
        long l = i;      // widening, safe
        double d = i;    // widening, safe
        Console.WriteLine(l + ", " + d);
    }
}

Warum erweiternde Konvertierungen sicher sind

Der Zieltyp kann jeden Wert des Quelltyps darstellen, daher lässt der Compiler die Konvertierung ohne weitere Angaben zu.

using System;

class Program
{
    static void Main()
    {
        byte b = 200;
        int i = b;       // byte fits in int
        Console.WriteLine("byte " + b + " -> int " + i);
    }
}

Explizite (verengende) Konvertierungen

Eine explizite Konvertierung, also ein Cast, ist erforderlich, wenn Daten verloren gehen könnten, etwa von double zu int. Sie schreiben (int)value.

using System;

class Program
{
    static void Main()
    {
        double d = 9.78;
        int i = (int)d;   // truncates toward zero -> 9
        Console.WriteLine(i);
    }
}

Casts kürzen, statt zu runden

Beim Casten eines Gleitkommawerts in eine Ganzzahl wird der Nachkommateil entfernt; der Wert wird nicht gerundet. Verwenden Sie zuerst Math.Round, wenn Sie runden möchten.

using System;

class Program
{
    static void Main()
    {
        double d = 7.99;
        Console.WriteLine("Cast: " + (int)d);
        Console.WriteLine("Round: " + (int)Math.Round(d));
    }
}

Überlauf bei verengenden Konvertierungen

Passt ein Wert nicht in den Zieltyp, kann ein einfacher Cast stillschweigend einen Überlauf verursachen. Verwenden Sie checked, damit stattdessen bei einem Überlauf eine Ausnahme ausgelöst wird.

using System;

class Program
{
    static void Main()
    {
        int big = 300;
        byte wrapped = (byte)big;   // 300 wraps to 44
        Console.WriteLine("Wrapped: " + wrapped);

        try
        {
            byte safe = checked((byte)big);
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("checked caught overflow");
        }
    }
}

Präzisionsverlust

Selbst bei einigen erweiternden Konvertierungen, etwa von einem sehr großen long zu float, kann Präzision verloren gehen, obwohl sie weiterhin implizit erfolgen.

using System;

class Program
{
    static void Main()
    {
        long big = 9007199254740993L;
        double approx = big;   // implicit, may lose precision
        Console.WriteLine("long: " + big);
        Console.WriteLine("double: " + approx.ToString("F0"));
    }
}

char- und numerische Konvertierungen

Ein char wird implizit in seinen numerischen Code konvertiert, und Sie können eine Zahl explizit wieder in einen char casten.

using System;

class Program
{
    static void Main()
    {
        char c = 'A';
        int code = c;          // implicit -> 65
        char next = (char)(code + 1);   // explicit -> B
        Console.WriteLine(code + " -> " + next);
    }
}

Konvertierungen in Ausdrücken

Bei gemischten arithmetischen Ausdrücken werden kleinere Typen vor der Operation automatisch in den größeren Typ konvertiert.

using System;

class Program
{
    static void Main()
    {
        int a = 7;
        double b = 2;
        double result = a / b;   // a promoted to double -> 3.5
        Console.WriteLine(result);
    }
}

Fallstrick bei der Ganzzahldivision

Sind beide Operanden Ganzzahlen, handelt es sich bei der Division um eine Ganzzahldivision. Casten Sie einen Operanden zuerst zu double, um ein Ergebnis mit Nachkommastellen zu erhalten.

using System;

class Program
{
    static void Main()
    {
        int a = 7, b = 2;
        Console.WriteLine("int / int: " + (a / b));
        Console.WriteLine("with cast: " + ((double)a / b));
    }
}

Alles zusammenführen

Bevorzugen Sie sichere implizite Konvertierungen, verwenden Sie bei verengenden Konvertierungen explizite Casts und achten Sie auf Abschneiden, Überläufe und Ganzzahldivision.

using System;

class Program
{
    static void Main()
    {
        int total = 17, count = 5;
        double average = (double)total / count;   // cast to avoid integer division
        int rounded = (int)Math.Round(average);
        Console.WriteLine("avg=" + average + ", rounded=" + rounded);
    }
}

Kurzer Test

Testen Sie Ihr Verständnis von Konvertierungen.

Rückblick

Implizite (erweiternde) Konvertierungen erfolgen automatisch, wenn keine Daten verloren gehen (int zu long, int zu double). Explizite (verengende) Konvertierungen benötigen einen Cast wie (int)x und können Werte abschneiden oder Überläufe verursachen. Verwenden Sie checked, um Überläufe zu erkennen, und casten Sie zu double, um Ganzzahldivision zu vermeiden.

using System;

class Program
{
    static void Main()
    {
        double d = 3.9;
        int i = (int)d;     // explicit, truncates to 3
        long l = i;          // implicit widening
        Console.WriteLine(i + ", " + l);
    }
}

Häufig gestellte Fragen

Ist die Lektion „Implizite und explizite Konvertierungen“ kostenlos?

Ja — der vollständige Text von „Implizite und explizite Konvertierungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Implizite und explizite Konvertierungen“?

Konvertieren Sie sicher zwischen kompatiblen Typen. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Implizite und explizite Konvertierungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy