0Pricing
C# Academy · Lección

Conversiones implícitas y explícitas

Convierta de forma segura entre tipos compatibles.

Conversiones implícitas y explícitas es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Conversión entre tipos

C# puede convertir un tipo numérico en otro. Algunas conversiones se realizan automáticamente (implícitas), mientras que otras requieren una conversión explícita.

using System;

class Program
{
    static void Main()
    {
        int i = 10;
        double d = i;       // implicit
        int back = (int)d;   // explicit
        Console.WriteLine(d + ", " + back);
    }
}

Conversiones implícitas (de ampliación)

Una conversión implícita está permitida cuando no se puede perder ningún dato, como al convertir int en long o int en double. No se necesita ninguna conversión explícita.

using System;

class Program
{
    static void Main()
    {
        int i = 42;
        long l = i;      // widening, safe
        double d = i;    // widening, safe
        Console.WriteLine(l + ", " + d);
    }
}

Por qué la ampliación es segura

El tipo destino puede representar todos los valores del tipo origen, por lo que el compilador permite la conversión sin avisos.

using System;

class Program
{
    static void Main()
    {
        byte b = 200;
        int i = b;       // byte fits in int
        Console.WriteLine("byte " + b + " -> int " + i);
    }
}

Conversiones explícitas (de reducción)

Se requiere una conversión explícita cuando podrían perderse datos, como al convertir double en int. Debe escribir (int)value.

using System;

class Program
{
    static void Main()
    {
        double d = 9.78;
        int i = (int)d;   // truncates toward zero -> 9
        Console.WriteLine(i);
    }
}

La conversión trunca, no redondea

Al convertir un valor de coma flotante en un entero se elimina la parte fraccionaria; no se redondea. Use primero Math.Round si desea redondear.

using System;

class Program
{
    static void Main()
    {
        double d = 7.99;
        Console.WriteLine("Cast: " + (int)d);
        Console.WriteLine("Round: " + (int)Math.Round(d));
    }
}

Desbordamiento en conversiones de reducción

Si un valor no cabe en el tipo destino, una conversión directa puede hacer que el valor dé la vuelta silenciosamente. Inclúyala en checked para producir una excepción en caso de desbordamiento.

using System;

class Program
{
    static void Main()
    {
        int big = 300;
        byte wrapped = (byte)big;   // 300 wraps to 44
        Console.WriteLine("Wrapped: " + wrapped);

        try
        {
            byte safe = checked((byte)big);
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("checked caught overflow");
        }
    }
}

Pérdida de precisión

Incluso algunas conversiones de ampliación, como convertir un long muy grande en float, pueden perder precisión aunque sigan siendo implícitas.

using System;

class Program
{
    static void Main()
    {
        long big = 9007199254740993L;
        double approx = big;   // implicit, may lose precision
        Console.WriteLine("long: " + big);
        Console.WriteLine("double: " + approx.ToString("F0"));
    }
}

char y las conversiones numéricas

Un char se convierte implícitamente en su código numérico, y puede convertir explícitamente un número de nuevo en un char.

using System;

class Program
{
    static void Main()
    {
        char c = 'A';
        int code = c;          // implicit -> 65
        char next = (char)(code + 1);   // explicit -> B
        Console.WriteLine(code + " -> " + next);
    }
}

Conversiones en expresiones

En operaciones aritméticas con tipos mixtos, los tipos más pequeños se promocionan automáticamente al tipo más grande antes de realizar la operación.

using System;

class Program
{
    static void Main()
    {
        int a = 7;
        double b = 2;
        double result = a / b;   // a promoted to double -> 3.5
        Console.WriteLine(result);
    }
}

El problema de la división entera

Si ambos operandos son enteros, la división es una división entera. Convierta primero uno de ellos en double para obtener un resultado fraccionario.

using System;

class Program
{
    static void Main()
    {
        int a = 7, b = 2;
        Console.WriteLine("int / int: " + (a / b));
        Console.WriteLine("with cast: " + ((double)a / b));
    }
}

Todo en conjunto

Prefiera las conversiones implícitas cuando sean seguras, use conversiones explícitas al reducir el tipo y tenga cuidado con el truncamiento, el desbordamiento y la división entera.

using System;

class Program
{
    static void Main()
    {
        int total = 17, count = 5;
        double average = (double)total / count;   // cast to avoid integer division
        int rounded = (int)Math.Round(average);
        Console.WriteLine("avg=" + average + ", rounded=" + rounded);
    }
}

Comprobación rápida

Compruebe su comprensión de las conversiones.

Resumen

Las conversiones implícitas (de ampliación) se realizan automáticamente cuando no se pierden datos (de int a long, de int a double). Las conversiones explícitas (de reducción) requieren una conversión como (int)x y pueden truncar o producir un desbordamiento. Use checked para detectar desbordamientos y convierta a double para evitar la división entera.

using System;

class Program
{
    static void Main()
    {
        double d = 3.9;
        int i = (int)d;     // explicit, truncates to 3
        long l = i;          // implicit widening
        Console.WriteLine(i + ", " + l);
    }
}

Preguntas frecuentes

¿La lección «Conversiones implícitas y explícitas» es gratis?

Sí — el texto completo de «Conversiones implícitas y explícitas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conversiones implícitas y explícitas»?

Convierta de forma segura entre tipos compatibles. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Conversiones implícitas y explícitas»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Tipos de valor frente a tipos de referencia
  2. Boxing y unboxing
  3. Conversiones implícitas y explícitas
  4. La clase Convert y el análisis
← Volver a C# Academy