explicit (référence C#)
Le mot clé explicit déclare un opérateur de conversion de type défini par l'utilisateur qui doit être appelé avec un cast. Par exemple, cet opérateur convertit d'une classe appelée Fahrenheit en une classe appelée 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));
}
Cet opérateur de conversion peut être appelé comme suit :
Fahrenheit fahr = new Fahrenheit(100.0f);
Console.Write("{0} Fahrenheit", fahr.Degrees);
Celsius c = (Celsius)fahr;
L'opérateur de conversion convertit un type source en type cible. Le type source fournit l'opérateur de conversion. À la différence de la conversion implicite, les opérateurs de conversion explicite doivent être appelés au moyen d'une conversion. Si une opération de conversion risque de provoquer des exceptions ou de perdre des informations, vous devez la marquer comme explicit. Ceci empêche le compilateur d'appeler en mode silencieux l'opération de conversion, ce qui pourrait entraîner des conséquences imprévisibles.
L'omission d'une conversion entraîne l'erreur de compilation CS0266.
Pour plus d’informations, consultez Utilisation d'opérateurs de conversion (Guide de programmation C#).
Exemple
L'exemple suivant fournit une classe Fahrenheit et une classe Celsius, chacune fournissant un opérateur de conversion explicite à l'autre classe.
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
L'exemple ci-dessous définit un struct, Digit, qui représente un seul chiffre décimal. Un opérateur est défini pour des conversions de byte à Digit, et comme tous les octets ne peuvent pas être convertis en Digit, la conversion est explicite.
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
*/
Spécification du langage C#
Pour plus d'informations, voir la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.
Voir aussi
Tâches
Référence
Concepts
Autres ressources
Conversions explicites définies par l'utilisateur liées en C#