War diese Seite hilfreich?
Ihr Feedback ist uns wichtig. Teilen Sie uns Ihre Meinung mit.
Weiteres Feedback?
1500 verbleibende Zeichen
explicit (C#-Referenz)
Collapse the table of content
Expand the table of content
Dieser Artikel wurde manuell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

explicit (C#-Referenz)

Das explicit-Schlüsselwort deklariert einen benutzerdefinierten Typkonvertierungsoperator, der mit einer Umwandlung aufgerufen werden muss. Der folgende Operator konvertiert zum Beispiel von der Klasse Fahrenheit in die Klasse Celsius:


// Must be defined inside a class called Fahrenheit:
public static explicit operator Celsius(Fahrenheit fahr)
{
    return new Celsius((5.0f / 9.0f) * (fahr.degrees - 32));
}


Dieser Konvertierungsoperator kann wie folgt aufgerufen werden:


Fahrenheit fahr = new Fahrenheit(100.0f);
Console.Write("{0} Fahrenheit", fahr.Degrees);
Celsius c = (Celsius)fahr;


Der Konvertierungsoperator konvertiert von einem Quelltyp in einen Zieltyp. Der Quelltyp stellt den Konvertierungsoperator bereit. Anders als bei der impliziten Konvertierung müssen explizite Konvertierungsoperatoren mittels einer Umwandlung aufgerufen werden. Ein Konvertierungsvorgang, durch den Ausnahmen verursacht oder Informationen verloren gehen können, sollte als explicit gekennzeichnet werden. Dadurch wird verhindert, dass der Compiler den Konvertierungsvorgang ohne Bestätigung aufruft, was u. U. unvorhersehbare Konsequenzen hätte.

Das Auslassen der Umwandlung verursacht den Kompilierungsfehler CS0266.

Weitere Informationen finden Sie unter Verwenden von Konvertierungsoperatoren (C#-Programmierhandbuch).

Im folgenden Beispiel werden eine Fahrenheit-Klasse und eine Celsius-Klasse bereitgestellt, die beide einen expliziten Operator für die Konvertierung in die jeweils andere Klasse bereitstellen.



class Celsius
{
    public Celsius(float temp)
    {
        degrees = temp;
    }
    public static explicit operator Fahrenheit(Celsius c)
    {
        return new Fahrenheit((9.0f / 5.0f) * c.degrees + 32);
    }
    public float Degrees
    {
        get { return degrees; }
    }
    private float degrees;
}

class Fahrenheit
{
    public Fahrenheit(float temp)
    {
        degrees = temp;
    }
    // Must be defined inside a class called Fahrenheit:
    public static explicit operator Celsius(Fahrenheit fahr)
    {
        return new Celsius((5.0f / 9.0f) * (fahr.degrees - 32));
    }
    public float Degrees
    {
        get { return degrees; }
    }
    private float degrees;
}

class MainClass
{
    static void Main()
    {
        Fahrenheit fahr = new Fahrenheit(100.0f);
        Console.Write("{0} Fahrenheit", fahr.Degrees);
        Celsius c = (Celsius)fahr;

        Console.Write(" = {0} Celsius", c.Degrees);
        Fahrenheit fahr2 = (Fahrenheit)c;
        Console.WriteLine(" = {0} Fahrenheit", fahr2.Degrees);
    }
}
// Output:
// 100 Fahrenheit = 37.77778 Celsius = 100 Fahrenheit


Im nachstehenden Beispiel wird eine Struktur Digit definiert, die eine einzelne Dezimalstelle repräsentiert. Für Konvertierungen von byte nach Digit wird ein Operator definiert. Hierbei handelt sich jedoch um eine explizite Konvertierung, da nicht alle Bytes in einen Digit-Wert konvertiert werden können.


struct Digit
{
    byte value;
    public Digit(byte value)
    {
        if (value > 9)
        {
            throw new ArgumentException();
        }
        this.value = value;
    }

    // Define explicit byte-to-Digit conversion operator:
    public static explicit operator Digit(byte b)
    {
        Digit d = new Digit(b);
        Console.WriteLine("conversion occurred");
        return d;
    }
}

class ExplicitTest
{
    static void Main()
    {
        try
        {
            byte b = 3;
            Digit d = (Digit)b; // explicit conversion
        }
        catch (Exception e)
        {
            Console.WriteLine("{0} Exception caught.", e);
        }
    }
}
/*
Output:
conversion occurred
*/


Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Anzeigen:
© 2015 Microsoft