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 Farenheit:
public static explicit operator Celsius(Fahrenheit f)
{
return new Celsius((5.0f / 9.0f) * (f.degrees - 32));
}
Dieser Konvertierungsoperator kann wie folgt aufgerufen werden:
Fahrenheit f = new Fahrenheit(100.0f);
Console.Write("{0} fahrenheit", f.Degrees);
Celsius c = (Celsius)f;
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).
Beispiel
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 Farenheit:
public static explicit operator Celsius(Fahrenheit f)
{
return new Celsius((5.0f / 9.0f) * (f.degrees - 32));
}
public float Degrees
{
get { return degrees; }
}
private float degrees;
}
class MainClass
{
static void Main()
{
Fahrenheit f = new Fahrenheit(100.0f);
Console.Write("{0} fahrenheit", f.Degrees);
Celsius c = (Celsius)f;
Console.Write(" = {0} celsius", c.Degrees);
Fahrenheit f2 = (Fahrenheit)c;
Console.WriteLine(" = {0} fahrenheit", f2.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
*/
C#-Programmiersprachenspezifikation
Weitere Informationen finden Sie in der C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.
Siehe auch
Aufgaben
Referenz
Konzepte
Weitere Ressourcen
Verkettete benutzerdefinierte explizite Konvertierungen in C#