Operatori in C#: aritmetici, modulo, logici, bitwise e precedenza

Un operatore prende uno, due o tre operandi e produce un valore: a + b, !done, x ?? fallback. Gli operatori di C# sono simili a quelli di C, Java e JavaScript, ma alcuni si comportano in modi che sorprendono chi inizia, soprattutto la divisione intera e il segno di %.

Operatori aritmetici

+, -, *, / e % funzionano su tutti i tipi numerici. Il tipo del risultato dipende dagli operandi: due valori int producono un int, un int e un double producono un double.

using System;

class Program
{
    static void Main()
    {
        int apples = 17, boxes = 5;

        Console.WriteLine(apples + boxes);   // 22
        Console.WriteLine(apples - boxes);   // 12
        Console.WriteLine(apples * boxes);   // 85
        Console.WriteLine(apples / boxes);   // 3: integer division
        Console.WriteLine(apples % boxes);   // 2: remainder

        Console.WriteLine(apples / 5.0);            // 3.4
        Console.WriteLine((double)apples / boxes);  // 3.4
        Console.WriteLine((double)(apples / boxes)); // 3: divided first, then converted
        Console.WriteLine(apples / 5m);             // 3.4 as decimal
    }
}

Output:

22
12
85
3
2
3.4
3.4
3
3.4

La divisione intera tronca verso lo zero. 17 / 5 vale 3 e -17 / 5 vale -3. È la causa di un bug molto comune: int percent = done / total * 100; vale 0 ogni volta che done < total, perché done / total è già 0. Moltiplica prima (done * 100 / total) oppure dividi come double.

Dividere un intero o un decimal per zero lancia DivideByZeroException. Dividere un double per zero non lancia nulla; produce infinito, oppure NaN per 0.0 / 0.0:

using System;

class Program
{
    static void Main()
    {
        double ratio = 5.0 / 0;
        double undefined = 0.0 / 0;
        Console.WriteLine(double.IsPositiveInfinity(ratio));
        Console.WriteLine(double.IsNaN(undefined));
        Console.WriteLine(undefined == undefined);   // NaN never equals anything

        int zero = 0;
        try
        {
            Console.WriteLine(10 / zero);
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("DivideByZeroException");
        }
    }
}

Output:

True
True
False
DivideByZeroException

L'operatore modulo e i numeri negativi

% restituisce il resto della divisione, e il suo risultato prende il segno dell'operando di sinistra. Questo è diverso da Python e dal "mod" matematico, che sono sempre non negativi con un divisore positivo:

using System;

class Program
{
    static int Mod(int a, int n)
    {
        return ((a % n) + n) % n;   // always in 0..n-1
    }

    static void Main()
    {
        Console.WriteLine(7 % 3);     // 1
        Console.WriteLine(-7 % 3);    // -1
        Console.WriteLine(7 % -3);    // 1
        Console.WriteLine(Mod(-7, 3)); // 2

        // Common uses:
        int n = 42;
        Console.WriteLine(n % 2 == 0 ? "even" : "odd");

        int totalSeconds = 3725;
        Console.WriteLine($"{totalSeconds / 60} min {totalSeconds % 60} s");

        string[] days = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
        int today = 5, offset = -9;
        Console.WriteLine(days[Mod(today + offset, 7)]);  // wraps backwards safely

        Console.WriteLine(7.5 % 2);   // works on double: 1.5
    }
}

Output:

1
-1
1
2
even
62 min 5 s
Thu
1.5

Usa la funzione di supporto Mod ogni volta che il lato sinistro può essere negativo e il risultato è un indice: days[(today + offset) % 7] lancerebbe una IndexOutOfRangeException con una somma negativa. Anche il test per i numeri dispari ha la stessa trappola: n % 2 == 1 è false per i numeri dispari negativi; verifica n % 2 != 0.

Assegnazione, assegnazione composta e incremento

= assegna. Le forme composte +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= combinano un'operazione con l'assegnazione. ++ e -- aggiungono o sottraggono 1, ed esistono in forma prefissa e postfissa, che differiscono nel valore che restituiscono:

using System;

class Program
{
    static void Main()
    {
        int stock = 10;
        stock -= 3;          // stock = stock - 3
        stock *= 2;          // stock = stock * 2
        Console.WriteLine(stock);   // 14

        string log = "start";
        log += ", step";     // += concatenates strings
        Console.WriteLine(log);

        int i = 5;
        int a = i++;   // a gets 5, then i becomes 6
        int b = ++i;   // i becomes 7, then b gets 7
        Console.WriteLine($"a={a} b={b} i={i}");

        byte level = 250;
        level += 10;   // compiles: compound assignment casts back to byte (and wraps)
        Console.WriteLine(level);
    }
}

Output:

14
start, step
a=5 b=7 i=7
4

Il caso del byte mostra una particolarità: level = level + 10; non compila, perché byte + int è un int, mentre level += 10; sì, perché l'assegnazione composta include un cast implicito verso il tipo della variabile. Quel cast ricomincia da capo in caso di overflow (250 + 10 diventa 4).

Operatori di confronto e logici

Gli operatori di confronto (==, !=, <, >, <=, >=) restituiscono un bool. Per le stringhe, == confronta il testo, non i riferimenti. Gli operatori logici sono ! (not), && (and), || (or) e ^ (or esclusivo).

using System;

class User
{
    public string Name;
    public bool IsActive;
}

class Program
{
    static bool Check(string label, bool result)
    {
        Console.WriteLine($"  evaluated {label}");
        return result;
    }

    static void Main()
    {
        Console.WriteLine(3 < 5 && "abc" == "ab" + "c");

        User user = null;
        // Safe: && stops at the first false, so user.IsActive is never read.
        if (user != null && user.IsActive)
            Console.WriteLine("active");
        else
            Console.WriteLine("no active user");

        Console.WriteLine("with ||:");
        bool r1 = Check("A", true) || Check("B", true);   // B is skipped

        Console.WriteLine("with |:");
        bool r2 = Check("A", true) | Check("B", true);    // both run

        Console.WriteLine(true ^ false);   // exactly one is true
    }
}

Output:

True
no active user
with ||:
  evaluated A
with |:
  evaluated A
  evaluated B
True

&& e || cortocircuitano: l'operando di destra viene eseguito solo quando può cambiare il risultato. È questo che rende sicuro user != null && user.IsActive. I singoli & e | sui booleani valutano sempre entrambi i lati, cosa che raramente vuoi in una condizione.

Operatori bitwise e di shift

Sui tipi interi, &, |, ^ e ~ lavorano sui singoli bit, e << e >> li spostano. Si usano per flag, maschere, hashing e protocolli di basso livello:

using System;

class Program
{
    const int Read = 1;     // 0001
    const int Write = 2;    // 0010
    const int Delete = 4;   // 0100

    static void Main()
    {
        int permissions = Read | Write;              // set two flags
        Console.WriteLine(permissions);                        // 3
        Console.WriteLine((permissions & Write) != 0);          // has Write?
        Console.WriteLine((permissions & Delete) != 0);         // has Delete?

        permissions |= Delete;                       // add a flag
        permissions &= ~Write;                       // remove a flag
        Console.WriteLine(Convert.ToString(permissions, 2));    // 101

        Console.WriteLine(1 << 10);                  // 1024
        Console.WriteLine(1000 >> 3);                // 125 (divide by 8)
        Console.WriteLine(6 ^ 3);                    // 110 xor 011 = 101 = 5
        Console.WriteLine(~0);                       // all bits set: -1
    }
}

Output:

3
True
False
101
1024
125
5
-1

Per insiemi di flag con un nome, un enum con l'attributo [Flags] è più chiaro delle costanti intere, e HasFlag si legge meglio di una maschera. C# 11 ha aggiunto >>>, uno shift a destra senza segno che riempie con zeri anche per i numeri negativi.

Operatori per null

Esistono tre operatori per lavorare con valori che possono essere null:

using System;

class Program
{
    static void Main()
    {
        string nickname = null;
        string display = nickname ?? "Guest";         // fallback when null
        Console.WriteLine(display);

        Console.WriteLine(nickname?.Length);          // null, not an exception
        int length = nickname?.Length ?? 0;
        Console.WriteLine(length);

        int? discount = null;
        Console.WriteLine(discount ?? 5);
    }
}

Output:

Guest

0
5

a ?? b restituisce a a meno che non sia null, altrimenti b. a?.Member restituisce null invece di lanciare un'eccezione quando a è null. C# 8 ha aggiunto a ??= b, che assegna b ad a solo quando a è null. Sono trattati a fondo nei tipi nullable.

Precedenza degli operatori

Quando un'espressione mescola operatori, le righe più in alto legano più strettamente. Gli operatori della stessa riga si raggruppano da sinistra a destra, tranne l'assegnazione, ?? e ?:, che si raggruppano da destra a sinistra. (Gli operandi vengono sempre valutati da sinistra a destra.)

Due conseguenze da conoscere: a + b * c moltiplica per prima cosa, e x & mask == 0 confronta per primo (== lega più strettamente di &), quindi significa x & (mask == 0) e non compila con gli interi. Scrivi (x & mask) == 0. Le parentesi non costano nulla e rendono evidente l'intenzione.

Overloading degli operatori

I tuoi tipi possono definire cosa significano gli operatori. È così che decimal, DateTime e TimeSpan supportano + e <:

using System;

struct Money
{
    public readonly decimal Amount;
    public Money(decimal amount) { Amount = amount; }

    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public static Money operator *(Money a, int n) => new Money(a.Amount * n);
    public static bool operator >(Money a, Money b) => a.Amount > b.Amount;
    public static bool operator <(Money a, Money b) => a.Amount < b.Amount;

    public override string ToString() => Amount.ToString("F2");
}

class Program
{
    static void Main()
    {
        var shirt = new Money(19.99m);
        var socks = new Money(4.50m);
        Money total = shirt + socks * 3;
        Console.WriteLine(total);
        Console.WriteLine(total > new Money(30m));
    }
}

Output:

33.49
True

Gli operatori devono essere public static, e alcuni vanno obbligatoriamente in coppia: definire < richiede >, e == richiede !=. Con == definito, il compilatore avvisa anche finché non ridefinisci Equals e GetHashCode in modo coerente. Fai l'overloading degli operatori solo dove il significato è ovvio, come con numeri, vettori e importi di denaro.