Opérateurs en C# : arithmétique, modulo, logique, bit à bit et priorité

Un opérateur prend un, deux ou trois opérandes et produit une valeur : a + b, !done, x ?? fallback. Les opérateurs de C# sont proches de ceux de C, Java et JavaScript, mais certains se comportent d'une façon qui surprend les débutants, surtout la division entière et le signe de %.

Opérateurs arithmétiques

+, -, *, / et % fonctionnent sur tous les types numériques. Le type du résultat dépend des opérandes : deux valeurs int produisent un int, un int et un double produisent 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
    }
}

Sortie :

22
12
85
3
2
3.4
3.4
3
3.4

La division entière tronque vers zéro. 17 / 5 vaut 3 et -17 / 5 vaut -3. Cela provoque un bug très courant : int percent = done / total * 100; vaut 0 dès que done < total, car done / total vaut déjà 0. Multipliez d'abord (done * 100 / total) ou divisez en double.

Diviser un entier ou un decimal par zéro lève DivideByZeroException. Diviser un double par zéro ne lève rien ; cela produit l'infini, ou NaN pour 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");
        }
    }
}

Sortie :

True
True
False
DivideByZeroException

L'opérateur modulo et les nombres négatifs

% renvoie le reste de la division, et son résultat prend le signe de l'opérande de gauche. C'est différent de Python et du « mod » mathématique, qui sont toujours positifs ou nuls pour un diviseur positif :

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

Sortie :

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

Utilisez la fonction Mod dès que la partie gauche peut être négative et que le résultat sert d'index : days[(today + offset) % 7] lèverait une IndexOutOfRangeException pour une somme négative. Tester si un nombre est impair présente le même piège : n % 2 == 1 vaut false pour les nombres impairs négatifs ; testez n % 2 != 0.

Affectation, affectation composée et incrémentation

= affecte. Les formes composées +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= combinent une opération et une affectation. ++ et -- ajoutent ou retirent 1, et existent en forme préfixe et suffixe, qui diffèrent par la valeur renvoyée :

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

Sortie :

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

Le cas du byte montre une particularité : level = level + 10; ne compile pas, car byte + int est un int, mais level += 10; compile, car l'affectation composée inclut un cast implicite vers le type de la variable. Ce cast boucle en cas de dépassement (250 + 10 devient 4).

Opérateurs de comparaison et logiques

Les opérateurs de comparaison (==, !=, <, >, <=, >=) renvoient un bool. Pour les chaînes, == compare le texte, pas les références. Les opérateurs logiques sont ! (non), && (et), || (ou) et ^ (ou exclusif).

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

Sortie :

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

&& et || court-circuitent : l'opérande de droite n'est évalué que lorsqu'il peut changer le résultat. C'est ce qui rend user != null && user.IsActive sûr. Les opérateurs simples & et | sur des booléens évaluent toujours les deux côtés, ce qui est rarement ce que l'on veut dans une condition.

Opérateurs bit à bit et de décalage

Sur les types entiers, &, |, ^ et ~ agissent sur les bits individuels, et << et >> les décalent. On s'en sert pour les drapeaux, les masques, le hachage et les protocoles bas niveau :

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

Sortie :

3
True
False
101
1024
125
5
-1

Pour des ensembles nommés de drapeaux, un enum avec l'attribut [Flags] est plus clair que des constantes entières, et HasFlag se lit mieux qu'un masque. C# 11 a ajouté >>>, un décalage à droite non signé qui remplit avec des zéros même pour les nombres négatifs.

Opérateurs null

Trois opérateurs servent à manipuler des valeurs qui peuvent être 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);
    }
}

Sortie :

Guest

0
5

a ?? b renvoie a sauf s'il vaut null, et sinon b. a?.Member renvoie null au lieu de lever une exception quand a vaut null. C# 8 a ajouté a ??= b, qui affecte b à a seulement quand a vaut null. Ils sont traités en détail dans types nullables.

Priorité des opérateurs

Quand une expression mélange des opérateurs, les lignes du haut lient plus fortement. Les opérateurs d'une même ligne se groupent de gauche à droite, sauf l'affectation, ?? et ?:, qui se groupent de droite à gauche. (Les opérandes eux-mêmes sont toujours évalués de gauche à droite.)

Deux conséquences à connaître : a + b * c multiplie d'abord, et x & mask == 0 compare d'abord (== lie plus fortement que &), donc cela signifie x & (mask == 0) et ne compile pas pour des entiers. Écrivez (x & mask) == 0. Les parenthèses ne coûtent rien et rendent l'intention évidente.

Surcharge d'opérateurs

Vos propres types peuvent définir la signification des opérateurs. C'est ainsi que decimal, DateTime et TimeSpan prennent en charge + et < :

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

Sortie :

33.49
True

Les opérateurs doivent être public static, et certains vont obligatoirement par paires : définir < impose >, et == impose !=. Avec == défini, le compilateur émet aussi un avertissement tant que vous n'avez pas redéfini Equals et GetHashCode en cohérence. Ne surchargez les opérateurs que là où le sens est évident, comme pour les nombres, les vecteurs et l'argent.