Tipos de datos fundamentales (Conversiones tipos de datos)

Conversiones de tipo de datos

C# es un lenguaje muy estricto en cuanto a conversiones de tipo. Existen dos tipos de conversiones: implíctas y explícitas.

Las implícitas son las que realiza el compilador sin requerir de nosotros la especificación de ninguna sentencia adicional. Este tipo de conversiones se caracteriza por el hecho de que nunca se pierde información ni precisión. La conversión es siempre válida. En el siguiente ejemplo es convertido a un entero largo. La conversión se da en la segunda línea y es implícita.

int n1 = 10;
long n2 = n1;

El otro tipo de conversión es explícito, y el compilador lo exige cuando podría ocurrir pérdida de información o precisión.

long n1 = 10;
int n2 = n1; // ----> Error!

El código anterior arrojará un error en la segunda línea, pues el compilador no puede realizar dicha conversión de modo implícito.
Para realizar una conversión explícita deberemos utilizar una expresión de casting. Esto significa especificar el tipo de dato sl cual deseamos llevar la expresión, ubicado entre paréntesis y antes de la expresión en cuestión:

long n1 = 10;
int n2 = (int) n1; // realizamos un cast

Ahora, el compilador ya no protesterá. Pero ¿ qué sucede si el número en n1 es más grande de lo que podría albergar n2? ¡Se pierde información! Es por está razón por lo que el compilador nos exige la conversión explícita, ya que es una manera de indicarle que nosotros sabemos lo que hacemos. Veamos el siguiente ejemplo:

long n1 = Int64.MaxValue;
int n2 = (int) n1; // realizamos un cast

Como es de suponer, en n2 no quedará el mismo valor que en n1, simplemente porque en n2 no hay lugar para albergar la magnitud que posee n1. Sin embargo, el compilador no arrojará error alguno. ¿Cómo decirle al compilador que deseamos ser alertados ante semejante circunstancia? Utilizando un bloque chequed como se muestra a continuación:

long n1 = Int64.MaxValue;

chequed{
int n2 = (int) n1; //realizamos un cast
}

Ahora, si la operación fracasa, el compilador arrojará una excepción. Esta excepción podrá ser capturada y tratada.

Y así como existe el bloque checked también existe su contrapartida, llamada unchecked. ¿Cuándo utilizaremos un bloque unchecked? Cuando el compilador no nos permita realizar una operación, a pesar de realizar una conversión de tipos explícita como la siguiente:

short n1 = 60000;

No hace falta ser un genio para saber que lo escrito en el código anterior fracasará. El rango de un short es de (-32768,32767), por lo que 60000 es un número demasiado grande. Tal vez el ejemplo sea trivial, pero si queremos que dicho código sea compilado de todos modos, entonces deberemos encerrarlo en un bloque unchecked.

unchecked{
short n1 = 60000;
}


La clase Convert

La librería BCL nos ofrece una clase llamada Convert dentro del espacio de nombres System, que es muy útil en el momento de realizar conversiones. La gran variedad de métodos estáticos que posee Convert nos permite pasar un tipo de dato primitivo a cualquier otro tipo de dato primitivo.
Por ejemplo, la siguiente operación no es válida debido a que intentamos pasar de un número entero a un tipo booleano.

bool a = 1;

Pero si, en cambio, escribimos:

bool a = Convert.ToBoolean(1);

Entonces la variable a, si recibe un número entero distinto de 0, será true, y en caso contrario, será false.


Operadores

Es posible combinar números y variables en expresiones por medio de operadores matemáticos. Veamos:

int a = 3 + 4; //Almaceno el número 7 en a

int a = 4;

int b = a / 2; //Almaceno en b el contenido de la variable dividido por 2


int a = 10;

int b = a + 14; //Almaceno en b el contenido de la variable multiplicado por 14


También podemos usar tipos de datos numéricos decimales:

float a = 3.4f / 2;

Y podremos combinar tipos de datos en operaciones:

int a = 5;
float b = 4.3f;
float resultado = a + b;

Sin embargo, cuando operamos de este modo es conveniente tener mucho cuidado, ya que el tipo de dato resultante estará en función de la operación que realicemos.

Por ejemplo, la suma de dos enteros dará como resultado un número entero, y la división de dos números enteros también dará como resultado un número entero; esto último es lo que precisamente puede traer muchos problemas. Este es el caso de que se quiera dividir 5 entre 2, el resultado que pensará cualquier persona es 2,5 lo cual no será expresado al consultar la variable en el computador, la cual es de tipo entera, la cual nos devolverá el valor 2. Colocar una variable para almacenar el resultado de tipo flotante no solucionará el problema.

float a = 5/2; //El resultado de la operación será 2

Para solucionar este inconveniente deberemos convertir al menos uno de los operandos en flotante, para que, de este modo, la división no sea entre números enteros, sino entre un entero y un número flotante:

float a = 5.0f/2; //Ahora el resultado será 2.5


Uso de constantes en operaciones

Utilizar constantes en lugar de números literales de manera directa es considerado una buena práctica, ya que facilita la lectura y comprensión del código fuente. Por ejemplo:

Constantes numéricas literales:
superficie = 3.1415f * 16;

Constantes declaradas:
const float pi = 3.1415f;
superficie = pi * (radio*radio);

El último listado de código es un poco más legible. Más alla de lo trivial del ejemplo, en otros casos podría no resultar tan obvio, en el análisis de una expresión que respresentan determinados números. En cambio, al ver una constante llamada pi rápidamente entenderemos a qué nos referimos.


https://msdn.microsoft.com/en-us/library/bb311038.aspx (Como convertir entre decimales y String, leer esto)


IMPORTANTE

http://www.codeproject.com/Tips/845439/Difference-between-int-Parse-Convert-ToInt-and-int
(Diferencia entre Parse, TryParse y Convert, muy bueno y sencillo este artículo)