1. Introducción
¿Alguna vez has intentado meter una sandía en una botella? Pues C# se enfrenta a algo parecido cada vez que le pides asignar una variable de un tipo a otro. A veces es fácil (convertir un número pequeño en uno grande — como meter una manzana en una maleta), y a veces hay que ir con cuidado (sandía en botella — aquí no te libras de problemas).
Conversión de tipo — es la operación de transformar un valor de un tipo de dato a otro. Esto suele hacer falta cuando quieres sumar o comparar valores de distintos tipos, o pasarlos a métodos que solo aceptan un tipo concreto.
En la vida real, los programadores se topan con esto todo el rato: haces pagos, calculas descuentos, haces cálculos físicos o, por ejemplo, parseas números que el usuario mete por teclado (ahí todo llega como string).
2. Conversión implícita de tipos (Implicit Conversion)
¿Qué es esto?
La conversión implícita es cuando C# decide por ti que se puede “mover” datos de un tipo a otro sin problemas. Todo pasa automáticamente — tú no escribes nada especial, solo usas los valores.
- El compilador no se queja.
- No necesitas comandos especiales ni casts.
- No hay pérdida de datos (bueno, casi nunca).
Ejemplo de conversión implícita
int a = 42;
double b = a; // Conversión implícita int -> double
Console.WriteLine(b); // 42 (pero ahora es 42.0)
Aquí a de tipo int se convierte automáticamente en double al asignarlo a la variable b. No hay pérdida de datos, porque todos los valores de int caben perfectamente en un double.
Aquí a de tipo int se convierte automáticamente en double al asignarlo a la variable b. No hay pérdida de datos, porque todos los valores de int caben perfectamente en un double.
¿Cuándo funciona esto?
- Cuando el tipo destino es más amplio que el tipo fuente — soporta un rango de datos más grande.
- No hay pérdida de datos.
- Ejemplos:
- int → long
- int → float / double
- float → double
- char → int
Otro ejemplo:
byte x = 100;
int y = x; // byte -> int (todos los valores de byte caben en int)
Tabla de conversiones implícitas para tipos numéricos
| From | To |
|---|---|
|
|
|
|
|
|
|
|
3. Conversión explícita de tipos (Explicit Conversion, Type Cast)
¿Cuándo no hay magia suficiente?
A veces el compilador no puede garantizar que la conversión sea segura, y te pide que asumas la responsabilidad — tienes que decirle explícitamente que eres consciente de los riesgos.
- Puedes perder datos.
- El formato del valor puede cambiar.
- A veces la conversión ni siquiera es posible — te dará error.
¿Cómo se escribe la conversión explícita?
Se usa la sintaxis entre paréntesis (cast):
double pi = 3.1415;
int wholePi = (int)pi; // Conversión explícita double -> int
Console.WriteLine(wholePi); // 3 (¡la parte decimal se pierde!)
¿Cuándo se usa?
- Cuando el tipo destino es más estrecho que el tipo fuente — el rango de valores del destino es menor que el del origen.
- Puedes perder la parte decimal, datos, o que haya overflow.
- Ejemplos:
- double → int
- long → int
- int → byte
- Casi cualquier salto entre tipos incompatibles.
4. Vamos con ejemplos
1) ¿Perdemos datos? ¡Vamos a comprobarlo!
Conversión implícita — todo ok!
int small = 25;
long big = small; // Conversión implícita (int -> long)
Console.WriteLine(big); // 25
Conversión explícita — zona peligrosa!
int big = 1000;
byte small = (byte)big; // Conversión explícita (int -> byte)
Console.WriteLine(small); // 232 (!), porque 1000 no cabe en byte (0..255)
Aquí el resultado es “mágico” 232, porque 1000 % 256 == 232.
2) Con números con coma flotante (double, float)
double number = 9.99;
int approximate = (int)number; // la parte decimal simplemente se pierde
Console.WriteLine(approximate); // 9
3) Conversión entre enteros y decimales (double ↔ int)
int apples = 5;
double exactApples = apples; // int -> double (implícito)
Console.WriteLine(exactApples); // 5.0
double bananaWeight = 2.77;
int weightForReport = (int)bananaWeight; // double -> int (explícito)
Console.WriteLine(weightForReport); // 2
5. ¿Qué hacer con la conversión de strings?: Parse y Convert
¡La conversión de tipos no funciona entre números y strings! Aquí necesitas métodos especiales, por ejemplo:
string strNumber = "123";
int num = int.Parse(strNumber); // o Convert.ToInt32(strNumber);
Pero al revés (int → string) pasa automáticamente al concatenar strings:
int number = 42;
string message = "Respuesta: " + number; // Conversión implícita int → string
6. Errores al convertir tipos
Lección de historia: una vez alguien se olvidó de hacer una conversión explícita, y el pago final fue 250 veces menor de lo que debía... ¡Estudiantes, atentos!
Error típico: intentar convertir implícitamente un tipo donde puede haber pérdida de datos.
int big = 500;
byte small = big; // Compilador: "¡No se puede! ¡Puede haber pérdida de datos!"
Aquí necesitas conversión explícita:
byte small = (byte)big; // ¡Pero te arriesgas a perder datos!
Otro bug típico — te olvidas de la parte decimal:
double x = 2.9;
int y = (int)x; // y == 2, la parte decimal desaparece
Para redondear según las reglas matemáticas, usa Math.Round:
int y = (int)Math.Round(x); // y == 3
7. Trampas de la conversión
- Pérdida de datos. Siempre revisa que el valor no se salga del rango permitido del tipo. Por ejemplo, int va de -2 147 483 648 a 2 147 483 647, y byte — solo 0–255.
- Redondeo. La conversión normal ((int)x) simplemente corta la parte decimal. Para redondear bien usa Math.Round, Math.Floor, Math.Ceiling.
- Literales numéricos. Ojo que 3 / 2 da 1 (división entera), pero 3.0 / 2 ya es 1.5 (double)!
- Operaciones de tipos mezclados. Si mezclas, por ejemplo, int y double en una expresión, el resultado será de tipo double.
GO TO FULL VERSION