C# Academy · Lektion

Benutzerdefinierte Konvertierungen

Fügen Sie implizite und explizite Konvertierungsoperatoren hinzu.

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

Benutzerdefinierte Konvertierungen

C# ermöglicht es einem Typ, mit den Operatoren implicit und explicit festzulegen, wie er in einen anderen Typ oder aus einem anderen Typ konvertiert wird. Implizite Konvertierungen erfolgen automatisch, explizite erfordern eine Typumwandlung.

Eine implizite Konvertierung

Verwenden Sie implicit operator, wenn eine Konvertierung immer sicher und ohne Informationsverlust ist. Der Compiler wendet sie automatisch überall dort an, wo der Zieltyp erwartet wird.

using System;

public struct Celsius
{
    public double Degrees;
    public Celsius(double d) { Degrees = d; }

    // Always safe: a Celsius is just a number
    public static implicit operator double(Celsius c) => c.Degrees;
}

public class Program
{
    public static void Main()
    {
        Celsius temp = new Celsius(21.5);
        double d = temp; // implicit, no cast needed
        Console.WriteLine(d);
    }
}

Eine explizite Konvertierung

Verwenden Sie explicit operator, wenn bei einer Konvertierung Informationen verloren gehen oder sie fehlschlagen kann. Aufrufer müssen eine Typumwandlung schreiben und signalisieren damit, dass sie das Risiko akzeptieren.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal a) { Amount = a; }

    // Loses the fractional cents, so make it explicit
    public static explicit operator int(Money m) => (int)m.Amount;
}

public class Program
{
    public static void Main()
    {
        var m = new Money(19.99m);
        int dollars = (int)m; // explicit cast required
        Console.WriteLine(dollars);
    }
}

In Ihren Typ konvertieren

Konvertierungen können auch in die andere Richtung erfolgen: von einem anderen Typ in Ihren Typ. Hier erstellt ein implicit-Operator aus einem einfachen double einen Celsius-Wert.

using System;

public struct Celsius
{
    public double Degrees;
    public Celsius(double d) { Degrees = d; }

    public static implicit operator Celsius(double d) => new Celsius(d);

    public override string ToString() => Degrees + "C";
}

public class Program
{
    public static void Main()
    {
        Celsius t = 18.0; // double implicitly becomes Celsius
        Console.WriteLine(t);
    }
}

Implizit oder explizit: die richtige Wahl

Als Faustregel gilt: Verwenden Sie implizit nur dann, wenn niemals Daten verloren gehen und niemals eine Ausnahme ausgelöst wird. Wenn Genauigkeit verloren gehen, ein Überlauf auftreten oder die Konvertierung fehlschlagen kann, verwenden Sie explizit.

using System;

public struct Percentage
{
    public double Value; // 0..1
    public Percentage(double v) { Value = v; }

    // Safe and lossless -> implicit
    public static implicit operator double(Percentage p) => p.Value;
    // Could be out of range -> explicit
    public static explicit operator Percentage(double v) => new Percentage(v);
}

public class Program
{
    public static void Main()
    {
        double d = new Percentage(0.25);
        var p = (Percentage)0.5;
        Console.WriteLine(d + " " + p.Value);
    }
}

Konvertierungen zwischen benutzerdefinierten Typen

Konvertierungen sind nicht auf integrierte Typen beschränkt. Sie können zwischen zwei eigenen Typen konvertieren, zum Beispiel von Polarkoordinaten in kartesische Koordinaten.

using System;

public struct Cartesian
{
    public double X, Y;
    public Cartesian(double x, double y) { X = x; Y = y; }
    public override string ToString() => "(" + Math.Round(X, 2) + ", " + Math.Round(Y, 2) + ")";
}

public struct Polar
{
    public double R, Theta;
    public Polar(double r, double theta) { R = r; Theta = theta; }
    public static explicit operator Cartesian(Polar p)
        => new Cartesian(p.R * Math.Cos(p.Theta), p.R * Math.Sin(p.Theta));
}

public class Program
{
    public static void Main()
    {
        var c = (Cartesian)new Polar(1.0, 0.0);
        Console.WriteLine(c);
    }
}

Konvertierungen funktionieren mit Operatoren

Sobald eine Konvertierung existiert, kann der Wert an Ausdrücken des Zieltyps teilnehmen. Eine implizite Konvertierung in double ermöglicht es, Ihren Typ direkt in arithmetischen Ausdrücken zu verwenden.

using System;

public struct Meters
{
    public double Value;
    public Meters(double v) { Value = v; }
    public static implicit operator double(Meters m) => m.Value;
}

public class Program
{
    public static void Main()
    {
        var distance = new Meters(5);
        double doubled = distance * 2; // uses implicit conversion to double
        Console.WriteLine(doubled);
    }
}

Vermeiden Sie überraschende implizite Konvertierungen

Implizite Konvertierungen, die nicht offensichtlich sicher sind, können Fehler verbergen, weil der Compiler sie stillschweigend anwendet. Wenn Sie unsicher sind, bevorzugen Sie die explizite Variante, damit die Absicht im Code sichtbar ist.

using System;

public struct UserId
{
    public int Value;
    public UserId(int v) { Value = v; }
    // Explicit on purpose: an int is not always a valid id
    public static explicit operator UserId(int v) => new UserId(v);
    public static explicit operator int(UserId id) => id.Value;
}

public class Program
{
    public static void Main()
    {
        var id = (UserId)42;
        int raw = (int)id;
        Console.WriteLine(raw);
    }
}

Konvertierungsoperatoren sind static

Wie andere Operatoren sind Konvertierungsoperatoren public static. Genau einer der beteiligten Typen muss der Typ sein, der den Operator deklariert.

using System;

public struct Fahrenheit
{
    public double Degrees;
    public Fahrenheit(double d) { Degrees = d; }
    public static implicit operator Fahrenheit(double d) => new Fahrenheit(d);
    public static implicit operator double(Fahrenheit f) => f.Degrees;
    public override string ToString() => Degrees + "F";
}

public class Program
{
    public static void Main()
    {
        Fahrenheit f = 98.6;
        double d = f;
        Console.WriteLine(f + " = " + d);
    }
}

Ein praktischer Wrapper-Typ

Konvertierungen sind besonders nützlich für einfache Wrapper-Typen, die das Typsystem ohne Umständlichkeit stärken. Hier wird ein NonEmptyString implizit in string konvertiert, während für die Erstellung ein expliziter Cast erforderlich ist.

using System;

public struct NonEmptyString
{
    public string Value;
    public NonEmptyString(string v)
    {
        if (string.IsNullOrEmpty(v)) throw new ArgumentException("empty");
        Value = v;
    }
    public static explicit operator NonEmptyString(string s) => new NonEmptyString(s);
    public static implicit operator string(NonEmptyString s) => s.Value;
}

public class Program
{
    public static void Main()
    {
        var name = (NonEmptyString)"Ada";
        string s = name;
        Console.WriteLine(s);
    }
}

Probieren Sie es selbst aus

Definieren Sie einen Wrapper mit einer impliziten Konvertierung nach außen, die sicher ist, und einer expliziten, validierten Konvertierung nach innen. Achten Sie darauf, für welche Richtung ein Cast erforderlich ist.

using System;

public struct Ratio
{
    public double Value;
    public Ratio(double v)
    {
        if (v < 0 || v > 1) throw new ArgumentOutOfRangeException(nameof(v));
        Value = v;
    }
    public static implicit operator double(Ratio r) => r.Value; // always safe
    public static explicit operator Ratio(double v) => new Ratio(v); // may throw
}

public class Program
{
    public static void Main()
    {
        var half = (Ratio)0.5;   // explicit, validated
        double d = half;          // implicit, safe
        Console.WriteLine(d * 100 + "%");
    }
}

Kurzer Test

Wählen Sie die passende Art der Konvertierung.

Zusammenfassung

Benutzerdefinierte Konvertierungen ermöglichen eine reibungslose Zusammenarbeit Ihrer Typen.

implicit operator für immer sichere, verlustfreie Konvertierungen.
explicit operator, wenn Daten verloren gehen oder die Konvertierung fehlschlagen kann.
Konvertierungen können auf integrierte oder benutzerdefinierte Typen und in beide Richtungen zielen.
Sie sind public static und werden von einem der beteiligten Typen deklariert.

Häufig gestellte Fragen

Ist die Lektion „Benutzerdefinierte Konvertierungen“ kostenlos?

Ja — der vollständige Text von „Benutzerdefinierte 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 „Benutzerdefinierte Konvertierungen“?

Fügen Sie implizite und explizite Konvertierungsoperatoren hinzu. 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 „Benutzerdefinierte 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