Operadores de conversión (Implícitos y Explícitos)

Es muy habitual realizar conversiones entre tipos de datos diferentes, por defecto muchos tipos de datos permiten la conversión implícita, esto se da en los casos en los cuales el tipo de dato de origen puede expresarse en su totalidad, como el Tipo de dato de destino, acá podemos ver un ejemplo:

byte valByte = 123;
int valInt = valByte;
double valDouble = valInt;

Como se ve en este caso no es necesario hacer ningún CAST, en cambio para el siguiente caso:

int valInt = 0;
byte valByte = valInt;

Tendriamos un error de compilación “Cannot implicitly convert type 'int' to 'byte'. An explicit conversion exists (are you missing a cast?)”, que nos indica que podemos hacer una conversión explícita, quedando resuelto de esta forma:

int valInt = 0;
byte valByte = (byte)valInt;

"Claro está que de esta manera, el Desarrollador está asumiendo los riesgos de obtener en la variable destino “valByte” información no esperada, si el valor origen “valInt” es superior al soportado por el tipo de dato Byte."

Conversión para clases definidas por el usuario

Desde la versión del .NET 2.0 podemos definir operadores de conversión para los tipos definidos por el usuario, como se puede ver en el siguiente ejemplo:

public class MyClase
{
public double valor;

/// <summary>
/// Permite la conversion implicita
/// desde Double hacia MyClase
/// </summary>
/// <param name="arg">Desde
/// <returns>Hacia</returns>
public static implicit operator MyClase(double arg)
{
MyClase res = new MyClase();
res.valor = arg;
return res;
}

/// <summary>
/// Permite la conversion implicita
/// desde MyClase hacia Double
/// </summary>
/// <param name="arg">Desde
/// <returns>Hacia</returns>
public static implicit operator double(MyClase arg)
{
return arg.valor;
}
}

public class MyClase2
{
public double valor;

/// <summary>
/// Permite la conversion explicita
/// desde Double hacia MyClase
/// </summary>
/// <param name="arg">Desde
/// <returns>Hacia</returns>
public static explicit operator MyClase2(double arg)
{
MyClase2 res = new MyClase2();
res.valor = arg;
return res;
}

/// <summary>
/// Permite la conversion explicita
/// desde MyClase hacia Double
/// </summary>
/// <param name="arg">Desde
/// <returns>Hacia</returns>
public static explicit operator double(MyClase2 arg)
{
return arg.valor;
}
}

En este caso la clase MyClase permite la conversión implícita con double, mientras que en la clase MyClase2 la conversión es explícita, la utilización de estas clases podría ser la siguiente:

double valDouble = 22;

MyClase myClase = new MyClase();
// Conversión implicita en ambos casos
valDouble = myClase;
myClase = valDouble;


MyClase2 myClase2 = new MyClase2();
// En este caso se requiere del CAST
valDouble = (double)myClase2;
myClase2 = (MyClase2)valDouble;

En resumen

Vimos un modo sencillo de implementar mecanismos de conversión entre tipos definidos por nosotros, generalmente entre tipos numéricos.
Otro modo de hacerlo es implementar System.IConvertible para utilizar la conversión a través de System.Convert, lo cual nos permite especificar la conversión por cultura.

Leer más...