Conversión entre Tipos

Conversión entre Tipos
La conversión entre tipos permite comparar y copiar valores entre diferentes tipos. En esta lección
describiremos como convertir un tipo dado en otro.
Conversión en VB y C#
Existen 2 tipos de conversiones entre tipos:

Conversión implícita: Son aquellas conversiones entre tipos que no requieren una sintaxis
especial en el código. Este tipo de conversiones se emplean cuando tipo destino puede
acomodar todos los valores posibles del tipo origen. Visual Basic por defecto permite la
conversión implícita entre tipos independientemente si el tipo destino puede acomodar todos
los valores del tipo origen. C# prohíbe las conversiones implícitas que causen una pérdida de
rango o precisión. Ejemplos de conversiones implícitas:
C#
int i = 3;
double d = 3.1416;
d = i;
// ahora d = 3
Visual Basic
Dim i as Integer = 1
Dim d as Double = 3.1416
d = i ' ahora d = 3

Conversión explícita: Son aquellas conversiones entre tipos que requieren el uso de palabras
reservadas del lenguaje o de de tipos del framework que ayudan en la conversión. Este tipo de
conversiones se emplean cuando el tipo destino no puede acomodar todos los posibles valores
del tipo origen y por lo tanto se requiere expresar explícitamente en el código esa intención. Las
conversiones explícitas de emplean cuando se conoce de antemano que el valor origen puede
ser convertido al tipo destino sin pérdida o error. Existen muchas maneras de realizar
conversiones explícitas, entre ellas:
A nivel de .Net Framework, esto es independiente del lenguaje elegido
System.Convert
Provee métodos que permiten la conversión entre tipos que implementan la interface
System.IConvertible. Todos los tipos de datos del Framework implementan IConvertible.
tipo.ToString
Para convertir el valor de una instancia a una cadena que lo representa. Donde “tipo” es
cualquier tipo de dato del framework o definido por el usuario que sobrecarga la función
“ToString”. Si la conversión no es posible se lanza una excepción.
tipo.Parse
Para convertir una representación en cadena a un tipo específico. Donde “tipo” es cualquier tipo
de dato básico del framework. Si la conversión no es posible se lanza una excepción.
tipo.TryParse y tipo.TryParseExact
Es similar al método “Parse”, sólo que no lanza una excepción si la conversión falla sino que
devuelve el valor booleano false.
En C#
(tipo) expresión
Los paréntesis se pueden utilizar para especificar conversiones de tipos. Donde “tipo” es el tipo
al que deseamos convertir, que tiene definido operadores de conversión. De esta manera se
invoca explícitamente al operador de conversión de un tipo a otro. La operación de conversión
falla y genera un error en tiempo de compilación si no hay un operador de conversión definido
entre los tipos que se desea convertir.
as
La palabra reservada “as” se utiliza para realizar conversiones entre tipos por referencia
compatibles, si la conversión no es posible se retorna null en vez de lanzar una excepción.
En VB
CType(expresión, tipo)
Es análogo al operador de conversión (tipo) expresión de C#.
CBool(expresión), CInt(expresión), CStr(expresión), etc.
Permiten la conversión entre los diferentes tipos básicos de Visual Basic. Estas funciones con
compiladas en línea, proporcionando una mejor performance. Se recomienda utilizar estas
funciones de conversión de tipos de Visual Basic en preferencia a las que proporciona .Net
Framework con el método ToString() o la Clase Convert, ya que estas funciones están
diseñadas para una interacción óptima con Visual Basic.
DirectCast(expresión, tipo)
Es similar a CType pero sólo opera en tipos por referencia. Para que la conversión sea exitosa
se requiere una relación de herencia o de implementación entre los tipos de datos de los
argumentos de lo contrario se lanza una excepción. Lo que significa que un tipo debe heredar o
implementar el otro.
TryCast(expresión, tipo)
Es exactamente igual a DirectCast salvo que en vez de lanzar una excepción cuando la
conversión no es posible devuelve Nothing.
Boxing y Unboxing
Boxing: Convierte un tipo por valor a un tipo por referencia. Cuando necesitamos tratar a tipos por
valor como enteros, booleanos o estructuras como si fueran referencias se construye un objeto del tipo
System.Object y se copia el valor a esa referencia. Boxing ocurre implícitamente cuando un tipo por
valor es pasado como parámetro a un tipo object. Por ello es recomendable no diseñar métodos que
acepten parámetros del tipo System.Object sino crear tantas sobrecargas del método como con tipos
por valor a utilizar. La operación de Boxing, también ocurre implícitamente cuando se llaman a métodos
virtuales de una estructura que hereda de System.Object, como por ejemplo el método ToString(),
GetHash() y Equals. Por ello se recomienda sobrecargar estos métodos cuando se definen estructuras o
nuevos tipos por valor.
C#
int p = 123;
object o;
o = p; // Boxing implícito
o = (object) p; // Boxing explícito
Visual Basic
Dim p as Integer = 123;
Dim o as Object;
o = CType(p, Object) ' Boxing explícito
Unboxing: Convierte un tipo por referencia a un tipo por valor. Ocurre cuando se asigna una referencia
de un objeto a un tipo por valor. El valor almacenado en la referencia de objeto es copiado en la
ubicación que ocupa el tipo por valor.
C#
int p;
p = (int) o; // Unboxing explícito
Visual Basic
Dim p as Integer
p = CType(o, Integer) ' Unboxing explícito
La operación de Unboxing debe ser realizada con un operador de conversión explícito, si el valor
almacenado en la referencia de objeto no es del mismo tipo del que se especifica en la conversión se
generará una excepción.
Consejos:
Evitar aceptar los argumentos del tipo Object en métodos, para ello se recomienda el uso de Generics ó
de crear varias sobrecargas del método en cuestión que acepte varios tipos por valor.
Implementando Conversiones en Tipos Definidos por el Usuario
Cuando creamos una aplicación muchas veces definimos tipos de datos propios para facilitar el manejo
de información por parte de la misma; ahora bien, para lograr una integración óptima con el framework,
debemos de tener en cuenta detalles como el manejo de conversión entre tipos y otras funcionalidades
que pueden ser logradas a través de la sobre escritura de métodos.
En este caso vamos a seguir concentrados en el tema de interés que hemos venido estudiando: las
conversiones. Hay varias formas de implementar –o habilitar en su defecto- las conversiones en tipos
que han sido definidos por uno mismo, y la técnica que escojamos dependerá del tipo de conversión que
queramos hacer. Las formas más comunes se enlistan a continuación:

Podemos definir los operadores de conversión para simplificar las conversiones de ampliación o
reducción entre tipos numéricos. (Recordemos las densidades de los conjuntos que son
representados por tipos int o float por ejemplo)

Veamos ahora la sobre escritura de los métodos toString y Parse para conversión entre nuestra
clase y la clase String. Esta es una muy buena práctica dado que como programadores asumimos
que cada objeto tiene bien definida la forma de presentarse como String, a pesar de que
generalmente no se implemente y quedamos con el nombre de la clase únicamente.

Adicionalmente podemos implementar la interface System.IConvertible para habilitar las
conversiones utilizando el método System.Convert.
Ampliando un poco más sobre operadores de conversión, los podemos definir como los que nos van a
permitir asignar de otros tipos hacia el nuestro y viceversa directamente. Ahora bien, usaremos la forma
implícita si estamos ampliando dado que no vamos a perder precisión, y usaremos la forma explícita
cuando por el otro lado se puede dar perdida de precisión. (Para visualizar mejor este concepto,
pensemos en que creamos un tipo de datos llamado ”Fracción”, que nos permite guardar números
fraccionales en términos de numerador y denominador. Si queremos convertir de nuestro tipo de datos
a un tipo de datos float por ejemplo, no hay perdida de precisión -técnicamente-, mientras si lo pasamos
a un Integer es todo lo contrario)
Pensando ahora en la sobre escritura de métodos, simplemente implementamos la interface
IConvertible y dejamos que el IDE implemente automáticamente la interface (él agregará métodos
según la interface, de los cuales modificamos los que sean relevantes para nuestro tipo de datos.
Ejemplo: probablemente el método ToDateTime sea irrelevante para nuestra clase Fracción).