Tipos integrados

C# cuenta con 16 tipos predefinidos integrados, divididos en 13 tipos simples y 3 tipos no simples. Todos los nombres de los tipos predefinidos se escriben completamente en minúsculas.

graph TD
    A[Tipos predefinidos] --> B[Simples]
    A --> C[object]
    A --> D[string]
    A --> E[dynamic]

    B --> F[No numéricos]
    B --> G[Numéricos]

    F --> H[bool]
    F --> I[char]

    G --> J[Enteros]
    G --> K[Coma flotante]

    J --> L[8 bits]
    J --> M[16 bits]
    J --> N[32 bits]
    J --> O[64 bits]

    L --> P[sbyte]
    L --> Q[byte]

    M --> R[short]
    M --> S[ushort]

    N --> T[int]
    N --> U[uint]

    O --> V[long]
    O --> W[ulong]

    K --> X[decimal]
    K --> Y[float]
    K --> Z[double]

    %% Nodos hoja en verde
    style H fill:#90ee90
    style I fill:#90ee90
    style P fill:#90ee90
    style Q fill:#90ee90
    style R fill:#90ee90
    style S fill:#90ee90
    style T fill:#90ee90
    style U fill:#90ee90
    style V fill:#90ee90
    style W fill:#90ee90
    style X fill:#90ee90
    style Y fill:#90ee90
    style Z fill:#90ee90
    style C fill:#90ee90
    style D fill:#90ee90
    style E fill:#90ee90

13 tipos simples

• Tipos numéricos (11 en total): 8 variantes de entero sbyte/byte, short/ushort, int/uint, long/ulong; 3 de coma flotante float, double, decimal (decimal diseñado exclusivamente para cálculos monetarios de alta precisión)
• Tipos no numéricos (2 en total): char (carácter Unicode individual), bool (solo valores true o false)

Característica: a diferencia de C/C++, los valores numéricos en C# no se pueden usar directamente como condición booleana.

3 tipos de referencia no simples

string (secuencia de caracteres), object (clase base de todos los tipos), dynamic (interoperabilidad con lenguajes dinámicos)

Tipos C# y tipos .NET

Cada tipo predefinido se mapea directamente a un tipo subyacente de .NET. Las palabras clave de tipo de C# son solo alias de sus correspondientes tipos .NET. El código compila correctamente si usas los nombres completos de las clases .NET, pero las guías oficiales de estilo lo desaconsejan. Al escribir código C#, prioriza los alias de palabra clave nativos de C# sobre los nombres completos de clase de .NET.

Tipos simples predefinidos

Tipos no simples predefinidos

int es completamente equivalente a System.Int32 y string coincide con System.String; el compilador los reconoce y convierte mutuamente de forma automática.

Las normas de codificación recomiendan encarecidamente usar las palabras clave nativas de C# (usa int en lugar de Int32) para mejorar la legibilidad del código.

Los tipos simples también se conocen como Tipos Valor (Value Type)

Almacenan un único valor y se asignan en la memoria de pila;

Si se declaran sin asignación manual, reciben automáticamente el valor por defecto indicado en la tabla;

Todos los tipos simples heredan directamente de object y admiten operaciones de empaquetado y desempaquetado (se explicará más adelante).

Familia de enteros

• Tipos con prefijo u (uint/ushort/ulong/byte): sin signo, solo almacenan números no negativos;
• sbyte/short/int/long: con signo, admiten enteros positivos y negativos.

Familia de coma flotante

• float: precisión simple, sufijo f. Menor precisión pero cálculos rápidos, ideal para gráficos y renderizado 3D;
• double: doble precisión, sufijo d. Tipo literal flotante por defecto, para cálculos científicos generales;
• decimal: decimal de alta precisión, sufijo m. Diseñado para finanzas y divisas sin pérdida de precisión en coma flotante.

Tipo booleano y tipo carácter

• bool: solo dos valores posibles, no se permite conversión implícita entre números y booleanos;
• char: almacena un único carácter Unicode, representado internamente como entero sin signo de 16 bits.

Tipos no simples (Tipos de referencia Reference Type)

1. object: clase base raíz. Todos los tipos valor y referencia derivan de él, pieza central del mecanismo de empaquetado;
2. string: tipo de referencia especial inmutable. La cadena vacía "" es una instancia por defecto válida;
3. dynamic: sin comprobación de tipos en tiempo de compilación, resuelve miembros en tiempo de ejecución. Sin mapeo .NET fijo, usado principalmente para integrar lenguajes dinámicos como Python/Ruby; sacrifica seguridad de compilación a cambio de flexibilidad.

    static void Main(string[] args)
    {
        // 1. Enteros de 8 bits
        sbyte sByteNum = -60;
        byte byteNum = 200;

        // 2. Enteros de 16 bits
        short shortNum = -12000;
        ushort uShortNum = 50000;

        // 3. Enteros de 32 bits
        int intNum = -888888;
        uint uIntNum = 3000000000U;

        // 4. Enteros de 64 bits
        long longNum = -7000000000000L;
        ulong uLongNum = 12000000000000000UL;

        // 5. Tipos de coma flotante
        float floatNum = 3.14f;
        double doubleNum = 2.71828;
        decimal decMoney = 999.99m;

        // 6. Tipo booleano
        bool flag = true;

        // 7. Carácter Unicode
        char ch = 'A';

        // 8. Tipos predefinidos no simples
        object obj = 123;
        string str = "FOXDEVELOP.COM";
        dynamic dy = "jack";
    }Lenguaje del código: C# (cs)

Tipos integrados