Tipos de datos en C#: int, double, decimal, char, bool y sus rangos

C# tiene tipado estático: cada variable, campo y expresión tiene un tipo conocido en tiempo de compilación. El lenguaje tiene un conjunto de tipos incorporados con palabras clave propias (int, double, string...). Cada palabra clave es un alias de un tipo del namespace System, así que int y System.Int32 son el mismo tipo, y string y System.String también.

Los tipos incorporados

Un literal entero sin sufijo es un int, o el primero de uint, long y ulong que pueda contenerlo si es demasiado grande para un int, y un literal con punto decimal es un double. Por eso float f = 2.5; y decimal d = 2.5; no compilan: el literal es un double, y no hay conversión implícita de double a float ni a decimal. Añade el sufijo: 2.5f, 2.5m.

Cada tipo numérico expone sus límites como constantes:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"byte:  {byte.MinValue} to {byte.MaxValue}");
        Console.WriteLine($"short: {short.MinValue} to {short.MaxValue}");
        Console.WriteLine($"int:   {int.MinValue} to {int.MaxValue}");
        Console.WriteLine($"long:  {long.MinValue} to {long.MaxValue}");
        Console.WriteLine($"decimal max: {decimal.MaxValue}");
        Console.WriteLine($"double max:  {double.MaxValue:E3}");
        Console.WriteLine($"sizes: int {sizeof(int)}, long {sizeof(long)}, double {sizeof(double)}, char {sizeof(char)}");

        int hex = 0xFF;             // hexadecimal
        int bits = 0b1010_0001;     // binary (C# 7)
        long big = 3_000_000_000;   // digit separators (C# 7)
        Console.WriteLine($"{hex} {bits} {big}");
    }
}

Salida:

byte:  0 to 255
short: -32768 to 32767
int:   -2147483648 to 2147483647
long:  -9223372036854775808 to 9223372036854775807
decimal max: 79228162514264337593543950335
double max:  1.798E+308
sizes: int 4, long 8, double 8, char 2
255 161 3000000000

En la práctica, la mayor parte del código usa cuatro de ellos: int para recuentos e índices, long para ID y totales grandes, double para medidas y matemáticas, y decimal para el dinero.

decimal frente a double

double (y float) guardan los números en binario. La mayoría de las fracciones decimales, incluida 0,1, no tienen una forma binaria exacta, así que se guardan como el valor representable más cercano y los pequeños errores se acumulan. decimal guarda un entero en base 10 más una escala, así que 0,1 es exactamente 0,1.

using System;

class Program
{
    static void Main()
    {
        double a = 0.1 + 0.2;
        decimal b = 0.1m + 0.2m;
        Console.WriteLine(a == 0.3);          // False
        Console.WriteLine(b == 0.3m);         // True
        Console.WriteLine(a.ToString("G17")); // 17 significant digits
        Console.WriteLine(b);

        double dsum = 0;
        decimal msum = 0;
        for (int i = 0; i < 10; i++)
        {
            dsum += 0.1;
            msum += 0.1m;
        }
        Console.WriteLine($"double sum == 1.0: {dsum == 1.0}");
        Console.WriteLine($"decimal sum == 1.0: {msum == 1.0m}");

        decimal price = 19.99m;
        int quantity = 3;
        decimal total = price * quantity;
        Console.WriteLine($"Total: {total}");
        Console.WriteLine($"Split three ways: {total / 3}");
    }
}

Salida:

False
True
0.30000000000000004
0.3
double sum == 1.0: False
decimal sum == 1.0: True
Total: 59.97
Split three ways: 19.99

Usa decimal para el dinero, los precios, los impuestos y todo lo que una persona vaya a sumar a mano y comparar. Conserva los ceros finales de sus entradas (1.50m se imprime como 1.50) y tiene de 28 a 29 dígitos significativos.

Usa double para medidas físicas, estadística, geometría y juegos. Es varias veces más rápido, usa la mitad de memoria y su rango es enorme. Nunca compares dos doubles calculados con ==; compara la diferencia con una tolerancia: Math.Abs(x - y) < 1e-9.

decimal no hace magia: 1m / 3m sigue siendo 0.3333333333333333333333333333, y la aritmética double no lanza una excepción al dividir entre cero (produce infinito, o NaN con 0.0 / 0.0), mientras que la división entre cero de decimal y de los enteros lanza una DivideByZeroException.

Desbordamiento de enteros y checked

La aritmética entera que supera el rango del tipo da la vuelta por defecto, en silencio. El compilador detecta el desbordamiento en las expresiones constantes, pero no cuando los valores vienen de variables:

using System;

class Program
{
    static void Main()
    {
        int max = int.MaxValue;
        int wrapped = max + 1;           // no error: wraps around
        Console.WriteLine(wrapped);

        try
        {
            int safe = checked(max + 1); // throws instead of wrapping
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("OverflowException");
        }

        long views = 3_000_000_000;
        int truncated = unchecked((int)views); // explicit narrowing keeps low 32 bits
        Console.WriteLine(truncated);

        long total = (long)max + 1;       // widen first to get the right answer
        Console.WriteLine(total);
    }
}

Salida:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) o un bloque checked { ... } convierte el desbordamiento en una OverflowException. También puedes activarlo para todo el proyecto con <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Escribir int x = int.MaxValue + 1; con constantes es un error de compilación (CS0220), porque el compilador puede ver el desbordamiento.

La última línea muestra la solución para la mayoría de los bugs de desbordamiento: convierte a un tipo más ancho antes de la aritmética. (long)(max + 1) estaría mal, porque la suma ya ha dado la vuelta cuando se ejecuta el cast.

Tipos de valor y tipos de referencia

Todo tipo de C# es un tipo de valor o un tipo de referencia, y la diferencia decide qué hace la asignación.

• Tipos de valor: todos los tipos numéricos, bool, char, DateTime, los enums y todos los struct. La variable contiene los datos; la asignación los copia.
• Tipos de referencia: string, los arrays, object y todas las class. La variable contiene una referencia a un objeto; la asignación copia la referencia, así que las dos variables ven el mismo objeto.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = a;      // copy of the value
        b = 99;
        Console.WriteLine($"a={a} b={b}");

        int[] first = { 1, 2, 3 };
        int[] second = first;   // copy of the reference
        second[0] = 99;
        Console.WriteLine($"first[0]={first[0]}");

        string s1 = "cat";
        string s2 = s1;
        s2 += "s";              // strings are immutable: s2 now refers to a new string
        Console.WriteLine($"s1={s1} s2={s2}");
    }
}

Salida:

a=10 b=99
first[0]=99
s1=cat s2=cats

string es un tipo de referencia que en la práctica se comporta como un valor: es inmutable, y == compara el texto, no las referencias. Más sobre los tipos de valor definidos por el usuario en structs.

char y bool

Un char es una unidad de código UTF-16, escrita entre comillas simples. Por debajo es un tipo numérico, así que se convierte a int y admite aritmética:

using System;

class Program
{
    static void Main()
    {
        char grade = 'B';
        Console.WriteLine((int)grade);           // 66
        Console.WriteLine((char)(grade + 1));    // C
        Console.WriteLine(char.IsLetter(grade));
        Console.WriteLine(char.IsDigit('7'));
        Console.WriteLine('7' - '0');             // digit char to its value
        Console.WriteLine(char.ToLower(grade));

        bool isOpen = true;
        bool hasStock = false;
        Console.WriteLine(isOpen && !hasStock);
    }
}

Salida:

66
C
True
True
7
b
True

bool tiene exactamente dos valores y no se convierte a números ni desde ellos: if (count) es un error de compilación, no una prueba de distinto de cero. Escribe if (count != 0). Los caracteres fuera del plano multilingüe básico, como la mayoría de los emoji, ocupan dos valores char (un par suplente), así que el Length de un string cuenta unidades UTF-16, no caracteres visibles.

Valores por defecto

Los campos, los elementos de los arrays y default(T) reciben el valor por defecto del tipo: cero para los números, false para bool, '\0' para char y null para los tipos de referencia. Las variables locales no reciben ningún valor por defecto y deben asignarse antes de usarse.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(default(int));
        Console.WriteLine(default(decimal));
        Console.WriteLine(default(bool));
        Console.WriteLine(default(string) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));

        var counts = new int[3];
        Console.WriteLine(string.Join(",", counts));
    }
}

Salida:

0
0
False
True
0001-01-01
0,0,0

Desde C# 7.1 puedes escribir el literal default sin el tipo cuando el compilador puede deducirlo (int x = default;). Un tipo de valor no puede ser null, y para eso existe int? (un tipo de valor nullable); consulta tipos nullable.

Enteros de tamaño nativo y enteros grandes

Existen dos tipos numéricos más para casos especiales. nint y nuint (C# 9) son enteros del tamaño de un puntero, de 32 o 64 bits según la plataforma, que se usan en la interoperabilidad y en código de bajo nivel. System.Numerics.BigInteger contiene enteros de cualquier tamaño, a costa de la velocidad:

using System.Numerics;
BigInteger factorial = 1;
for (int i = 2; i <= 30; i++) factorial *= i;
// 265252859812191058636308480000000