Tipi di dati in C#: int, double, decimal, char, bool e i loro intervalli

C# è a tipizzazione statica: ogni variabile, campo ed espressione ha un tipo noto in fase di compilazione. Il linguaggio ha un insieme di tipi predefiniti con parole chiave proprie (int, double, string...). Ogni parola chiave è un alias di un tipo del namespace System, quindi int e System.Int32 sono lo stesso tipo, così come string e System.String.

I tipi predefiniti

Un letterale intero senza suffisso è un int, oppure il primo tra uint, long e ulong in grado di contenerlo se è troppo grande per un int, e un letterale con il punto decimale è un double. Ecco perché float f = 2.5; e decimal d = 2.5; non compilano: il letterale è un double, e non esiste una conversione implicita da double a float o decimal. Aggiungi il suffisso: 2.5f, 2.5m.

Ogni tipo numerico espone i propri limiti come costanti:

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

Output:

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

In pratica la maggior parte del codice ne usa quattro: int per conteggi e indici, long per ID e totali grandi, double per misure e calcoli matematici, e decimal per il denaro.

decimal vs double

double (e float) memorizzano i numeri in binario. La maggior parte delle frazioni decimali, 0.1 compreso, non ha una forma binaria esatta, quindi viene memorizzata come il valore rappresentabile più vicino e piccoli errori si accumulano. decimal memorizza un intero in base 10 più una scala, quindi 0.1 è esattamente 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}");
    }
}

Output:

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 per denaro, prezzi, tasse e qualsiasi cosa una persona sommerà a mano e confronterà. Conserva gli zeri finali dei suoi input (1.50m viene stampato come 1.50) e ha da 28 a 29 cifre significative.

Usa double per misure fisiche, statistica, geometria e giochi. È varie volte più veloce, usa metà della memoria e il suo intervallo è enorme. Non confrontare mai due double calcolati con ==; confronta la differenza con una tolleranza: Math.Abs(x - y) < 1e-9.

decimal non fa miracoli: 1m / 3m resta comunque 0.3333333333333333333333333333, e l'aritmetica con double non lancia eccezioni nella divisione per zero (produce infinito, o NaN per 0.0 / 0.0), mentre la divisione per zero con decimal e con gli interi lancia una DivideByZeroException.

Overflow degli interi e checked

L'aritmetica intera che supera l'intervallo del tipo per impostazione predefinita ricomincia dall'altro estremo, in silenzio. Il compilatore rileva l'overflow nelle espressioni costanti, ma non quando i valori arrivano da variabili:

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

Output:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) o un blocco checked { ... } trasforma l'overflow in una OverflowException. Puoi anche attivarlo per l'intero progetto con <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Scrivere int x = int.MaxValue + 1; con delle costanti è un errore di compilazione (CS0220), perché il compilatore vede l'overflow.

L'ultima riga mostra la soluzione per la maggior parte dei bug di overflow: convertire in un tipo più ampio prima dell'operazione. (long)(max + 1) sarebbe sbagliato, perché quando il cast viene eseguito l'addizione è già andata in overflow.

Tipi valore e tipi riferimento

Ogni tipo C# è un tipo valore o un tipo riferimento, e la differenza decide cosa fa l'assegnazione.

• Tipi valore: tutti i tipi numerici, bool, char, DateTime, gli enum e ogni struct. La variabile contiene il dato; l'assegnazione lo copia.
• Tipi riferimento: string, gli array, object e ogni class. La variabile contiene un riferimento a un oggetto; l'assegnazione copia il riferimento, quindi entrambe le variabili vedono lo stesso oggetto.

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

Output:

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

string è un tipo riferimento che in pratica si comporta come un valore: è immutabile, e == confronta il testo, non i riferimenti. Trovi di più sui tipi valore definiti dall'utente nelle struct.

char e bool

Un char è una unità di codice UTF-16, scritta tra apici singoli. Sotto sotto è un tipo numerico, quindi si converte in int e supporta l'aritmetica:

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

Output:

66
C
True
True
7
b
True

bool ha esattamente due valori e non si converte da o verso i numeri: if (count) è un errore di compilazione, non un controllo sul diverso da zero. Scrivi if (count != 0). I caratteri fuori dal Basic Multilingual Plane, come la maggior parte delle emoji, occupano due valori char (una coppia surrogata), quindi la Length di una string conta le unità UTF-16, non i caratteri visibili.

Valori predefiniti

Campi, elementi di array e default(T) ricevono il valore predefinito del tipo: zero per i numeri, false per bool, '\0' per char e null per i tipi riferimento. Le variabili locali non ricevono alcun valore predefinito e vanno assegnate prima dell'uso.

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

Output:

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

Da C# 7.1 puoi scrivere il letterale default senza il tipo quando il compilatore riesce a dedurlo (int x = default;). Un tipo valore non può essere null, ed è a questo che serve int? (un tipo valore nullable); vedi i tipi nullable.

Interi a dimensione nativa e interi grandi

Esistono altri due tipi numerici per casi speciali. nint e nuint (C# 9) sono interi grandi quanto un puntatore, 32 o 64 bit a seconda della piattaforma, usati nell'interoperabilità e nel codice a basso livello. System.Numerics.BigInteger contiene interi di qualsiasi dimensione, a scapito della velocità:

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