Tipos Integrados

O C# disponibiliza 16 tipos predefinidos integrados, divididos em 13 tipos simples e 3 tipos não simples. Todos os nomes dos tipos predefinidos são escritos exclusivamente em minúsculas.

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

    B --> F[Não Numéricos]
    B --> G[Numéricos]

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

    G --> J[Inteiros]
    G --> K[Ponto Flutuante]

    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]

    %% Define os nós folha com cor 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 no total): 8 variantes inteiras sbyte/byte, short/ushort, int/uint, long/ulong; 3 variantes de ponto flutuante float, double, decimal (o decimal é concebido unicamente para cálculos monetários de alta precisão)
• Tipos não numéricos (2 no total): char (caráter Unicode individual), bool (apenas aceita os valores true ou false)

Característica distintiva: ao contrário do C/C++, os valores numéricos do C# não podem ser usados diretamente como condição lógica em validações booleanas.

3 Tipos de Referência Não Simples

string (sequência de caracteres), object (classe base de todos os tipos), dynamic (para interoperabilidade com linguagens dinâmicas)

Tipos C# e Tipos .NET

Cada tipo predefinido mapeia diretamente para um tipo subjacente do .NET. As palavras-chave de tipo do C# são apenas pseudónimos dos tipos .NET correspondentes. O código compila normalmente se forem utilizados os nomes completos das classes .NET, mas as diretrizes oficiais de codificação desaconselham esta prática. Ao escrever código C#, deve privilegiar os pseudónimos das palavras-chave nativas do C# em detrimento dos nomes completos das classes do .NET.

Tipos Simples Predefinidos

Tipos Não Simples Predefinidos

int é totalmente equivalente a System.Int32 e string corresponde exatamente a System.String; o compilador reconhece e converte ambas as formas automaticamente.

As normas de escrita de código obrigam à utilização das palavras-chave nativas do C# (escreva int em vez de Int32) para aumentar a legibilidade do código.

Os tipos simples também são designados por Tipos de Valor (Value Type)

Armazenam um único valor e são alocados na memória de pilha;

Se forem declarados sem atribuição manual de valor, recebem automaticamente o valor padrão indicado na tabela;

Todos os tipos simples herdam diretamente de object e suportam as operações de boxing e unboxing (explicado mais adiante no texto).

Família dos Inteiros

• Tipos com prefixo u (uint/ushort/ulong/byte): sem sinal, apenas guardam números não negativos;
• sbyte/short/int/long: com sinal, conseguem armazenar inteiros positivos e negativos.

Família dos Pontos Flutuantes

• float: precisão simples, sufixo f. Menor precisão mas cálculos rápidos, ideal para gráficos e simulações 3D;
• double: precisão dupla, sufixo d. Tipo padrão para literais de ponto flutuante, usado em cálculos científicos genéricos;
• decimal: decimal de alta precisão, sufixo m. Desenvolvido para cálculos financeiros e cambiais, sem perda de precisão no ponto flutuante.

Tipo Lógico e Tipo de Caráter

• bool: dispõe apenas de dois valores válidos, não é permitida conversão implícita entre números e lógicos;
• char: guarda um único caráter Unicode, representado internamente como um inteiro sem sinal de 16 bits.

Tipos Não Simples (Tipos de Referência Reference Type)

1. object: classe base raiz. Todos os tipos de valor e de referência derivam dela, sendo o núcleo do mecanismo de boxing;
2. string: tipo de referência especial imutável. A cadeia vazia "" corresponde a uma instância padrão válida;
3. dynamic: não realiza validação de tipos em tempo de compilação, resolve os membros apenas em tempo de execução. Não possui mapeamento .NET fixo, usado principalmente para integração com linguagens dinâmicas como Python ou Ruby; sacrifica a segurança da compilação para obter maior flexibilidade.

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

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

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

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

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

        // 6. Tipo lógico
        bool flag = true;

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

        // 8. Tipos predefinidos não simples
        object obj = 123;
        string str = "FOXDEVELOP.COM";
        dynamic dy = "jack";
    }Code language: C# (cs)

Tipos Integrados