Types de données en C# : int, double, decimal, char, bool et leurs plages

C# est typé statiquement : chaque variable, champ et expression a un type connu à la compilation. Le langage possède un ensemble de types intégrés dotés de leurs propres mots-clés (int, double, string...). Chaque mot-clé est un alias d'un type du namespace System : int et System.Int32 sont le même type, tout comme string et System.String.

Les types intégrés

Un littéral entier sans suffixe est un int, ou le premier type parmi uint, long et ulong capable de le contenir s'il est trop grand pour un int, et un littéral avec un point décimal est un double. C'est pourquoi float f = 2.5; et decimal d = 2.5; ne compilent pas : le littéral est un double, et il n'existe pas de conversion implicite de double vers float ou decimal. Ajoutez le suffixe : 2.5f, 2.5m.

Chaque type numérique expose ses limites sous forme de 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}");
    }
}

Sortie :

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 pratique, la plupart du code utilise quatre de ces types : int pour les compteurs et les index, long pour les identifiants et les grands totaux, double pour les mesures et les calculs, et decimal pour l'argent.

decimal ou double

double (et float) stockent les nombres en binaire. La plupart des fractions décimales, dont 0,1, n'ont pas de forme binaire exacte : elles sont stockées comme la valeur représentable la plus proche, et de petites erreurs s'accumulent. decimal stocke un entier en base 10 plus une échelle, donc 0,1 vaut exactement 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}");
    }
}

Sortie :

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

Utilisez decimal pour l'argent, les prix, les taxes et tout ce qu'une personne additionnera à la main et comparera. Il conserve les zéros de fin de ses entrées (1.50m s'affiche 1.50) et a 28 à 29 chiffres significatifs.

Utilisez double pour les mesures physiques, les statistiques, la géométrie et les jeux. Il est plusieurs fois plus rapide, utilise moitié moins de mémoire, et sa plage est énorme. Ne comparez jamais deux doubles calculés avec == ; comparez leur différence à une tolérance : Math.Abs(x - y) < 1e-9.

decimal n'a rien de magique : 1m / 3m donne toujours 0.3333333333333333333333333333, et l'arithmétique double ne lève pas d'exception sur une division par zéro (elle produit l'infini, ou NaN pour 0.0 / 0.0), alors que la division par zéro en decimal et en entier lève une DivideByZeroException.

Dépassement d'entier et checked

Une opération entière qui dépasse la plage du type boucle par défaut, silencieusement. Le compilateur détecte le dépassement dans les expressions constantes, mais pas quand les valeurs viennent 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);
    }
}

Sortie :

-2147483648
OverflowException
-1294967296
2147483648

checked(...) ou un bloc checked { ... } transforme le dépassement en OverflowException. Vous pouvez aussi l'activer pour tout le projet avec <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Écrire int x = int.MaxValue + 1; avec des constantes est une erreur de compilation (CS0220), car le compilateur voit le dépassement.

La dernière ligne montre la correction de la plupart des bugs de dépassement : convertir vers un type plus large avant le calcul. (long)(max + 1) serait faux, puisque l'addition a déjà bouclé au moment où la conversion s'exécute.

Types valeur et types référence

Chaque type C# est soit un type valeur, soit un type référence, et cette différence détermine ce que fait l'affectation.

• Types valeur : tous les types numériques, bool, char, DateTime, les enums et chaque struct. La variable contient la donnée ; l'affectation la copie.
• Types référence : string, les tableaux, object et chaque class. La variable contient une référence vers un objet ; l'affectation copie la référence, donc les deux variables voient le même objet.

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}");
    }
}

Sortie :

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

string est un type référence qui se comporte en pratique comme une valeur : il est immuable, et == compare le texte, pas les références. Plus de détails sur les types valeur définis par l'utilisateur dans structs.

char et bool

Un char est une unité de code UTF-16, écrite entre apostrophes. C'est un type numérique en interne, il se convertit donc en int et accepte l'arithmétique :

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);
    }
}

Sortie :

66
C
True
True
7
b
True

bool a exactement deux valeurs et ne se convertit pas vers ou depuis des nombres : if (count) est une erreur de compilation, pas un test de non-nullité. Écrivez if (count != 0). Les caractères situés hors du plan multilingue de base, comme la plupart des emoji, occupent deux valeurs char (une paire de substitution), donc la Length d'une string compte des unités UTF-16, pas des caractères visibles.

Valeurs par défaut

Les champs, les éléments de tableau et default(T) reçoivent la valeur par défaut du type : zéro pour les nombres, false pour bool, '\0' pour char et null pour les types référence. Les variables locales n'ont pas de valeur par défaut et doivent être affectées avant utilisation.

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));
    }
}

Sortie :

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

Depuis C# 7.1, vous pouvez écrire le littéral default sans le type quand le compilateur peut le déduire (int x = default;). Un type valeur ne peut pas valoir null ; c'est à cela que sert int? (un type valeur nullable), voir types nullables.

Entiers de taille native et grands entiers

Deux autres types numériques existent pour des cas particuliers. nint et nuint (C# 9) sont des entiers de la taille d'un pointeur, 32 ou 64 bits selon la plateforme, utilisés dans l'interopérabilité et le code bas niveau. System.Numerics.BigInteger contient des entiers de taille quelconque, au prix de la vitesse :

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