explicit (Referencia de C#)
Actualización: noviembre 2007
La palabra clave explicit declara un operador de conversión de tipos definido por el usuario que se debe invocar con una conversión de tipos. Por ejemplo, este operador convierte una clase denominada Fahrenheit en una clase denominada 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));
}
El operador de conversión se puede invocar así:
Fahrenheit f = new Fahrenheit(100.0f);
Console.Write("{0} fahrenheit", f.Degrees);
Celsius c = (Celsius)f;
El operador de conversión convierte un tipo de origen en un tipo de destino. El tipo de origen proporciona el operador de conversión. A diferencia de la conversión implícita, los operadores de conversión explícita deben invocarse mediante una conversión de tipo (cast). Si una operación de conversión puede producir excepciones o pérdida de información, debe marcarse como explicit. De esta forma, se evita que el compilador realice la conversión automáticamente y se produzcan posibles consecuencias no deseadas.
Si no se utiliza esta conversión explícita, se produce el error de compilación Error del compilador CS0266.
Para obtener más información, vea Utilizar operadores de conversión (Guía de programación de C#).
Ejemplo
El ejemplo siguiente proporciona una clase Fahrenheit y una clase Celsius, cada una de las cuales proporciona un operador de conversión explícito a la otra clase.
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
*/
El siguiente ejemplo define una estructura, Digit, que representa un único dígito decimal. Se define un operador para conversiones de byte a Digit, pero como no todos los bytes se pueden convertir en Digit, la conversión es explícita.
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
*/
Especificación del lenguaje C#
Para obtener más información, vea las secciones siguientes de Especificación del lenguaje C#.
- 6.2 Conversiones explícitas