Types intégrés

C# propose 16 types prédéfinis intégrés, divisés en 13 types simples et 3 types non simples. Tous les noms des types prédéfinis s’écrivent entièrement en minuscules.

graph TD
    A[Types prédéfinis] --> B[Simples]
    A --> C[object]
    A --> D[string]
    A --> E[dynamic]

    B --> F[Non numériques]
    B --> G[Numériques]

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

    G --> J[Entiers]
    G --> K[Virgule flottante]

    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]

    %% Colorier les feuilles en vert
    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 types simples

• Types numériques (11 au total) : 8 entiers sbyte/byte, short/ushort, int/uint, long/ulong ; 3 types à virgule flottante float, double, decimal (decimal dédié aux calculs monétaires haute précision)
• Types non numériques (2 au total) : char (caractère Unicode unique), bool (seules valeurs true ou false)

Caractéristique : contrairement au C/C++, les valeurs numériques de C# ne peuvent pas être utilisées directement comme condition booléenne.

3 types référence non simples

string (suite de caractères), object (classe racine de tous les types), dynamic (interopérabilité avec langages dynamiques)

Types C# et types .NET

Chaque type prédéfini mappe directement sur un type sous-jacent .NET. Les mots-clés de type C# ne sont que des alias des types .NET correspondants. Le code compile si vous utilisez les noms complets des classes .NET, mais les conventions officielles le déconseillent. Sur du code C#, privilégiez systématiquement les alias mots-clés natifs plutôt que les noms complets .NET.

Types simples prédéfinis

Types non simples prédéfinis

int est strictement équivalent à System.Int32 et string à System.String ; le compilateur les reconnaît et convertit mutuellement automatiquement.

Les règles de codage imposent d’utiliser les mots-clés C# (préférez int plutôt que Int32) pour améliorer la lisibilité du code.

Les types simples sont aussi appelés types valeur (Value Type)

Ils stockent une unique valeur et sont alloués sur la pile mémoire ;

Lorsqu’une variable est déclarée sans affectation manuelle, elle reçoit automatiquement la valeur par défaut indiquée dans le tableau ;

Tous les types simples héritent directement de object et prennent en charge les opérations de boxing et unboxing (détaillées plus loin).

Famille des entiers

• Types préfixés par u (uint/ushort/ulong/byte) : non signés, ne stockent que des nombres positifs ou nuls ;
• sbyte/short/int/long : signés, acceptent entiers positifs et négatifs.

Famille des nombres à virgule flottante

• float : simple précision, suffixe f. Peu précis mais calculs rapides, adapté aux graphismes et rendus 3D ;
• double : double précision, suffixe d. Type littéral flottant par défaut pour calculs scientifiques génériques ;
• decimal : décimal haute précision, suffixe m. Conçu pour la finance et devises, sans perte de précision sur les flottants.

Type booléen et type caractère

• bool : deux valeurs uniquement, conversion implicite interdite avec les nombres ;
• char : stocke un seul caractère Unicode, représenté en interne par un entier 16 bits non signé.

Types non simples (types référence Reference Type)

1. object : classe racine universelle. Tous les types valeur et référence en héritent, cœur du mécanisme de boxing ;
2. string : type référence spécial immuable. La chaîne vide "" est une instance par défaut valide ;
3. dynamic : pas de vérification de type à la compilation, résolution des membres à l’exécution. Aucun mapping .NET fixe, utilisé principalement pour interagir avec Python/Ruby et autres langages dynamiques ; sacrifie la sûreté de compilation pour plus de flexibilité.

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

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

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

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

        // 5. Types virgule flottante
        float floatNum = 3.14f;
        double doubleNum = 2.71828;
        decimal decMoney = 999.99m;

        // 6. Type booléen
        bool flag = true;

        // 7. Caractère Unicode
        char ch = 'A';

        // 8. Types prédéfinis non simples
        object obj = 123;
        string str = "FOXDEVELOP.COM";
        dynamic dy = "jack";
    }Langage du code : JavaScript (javascript)

Types intégrés