C# Operatoren: Arithmetik, Modulo, logisch, bitweise und Rangfolge

Ein Operator nimmt einen, zwei oder drei Operanden und erzeugt einen Wert: a + b, !done, x ?? fallback. Die Operatoren von C# ähneln denen von C, Java und JavaScript, aber einige verhalten sich überraschend für Einsteiger, allen voran die Ganzzahldivision und das Vorzeichen von %.

Arithmetische Operatoren

+, -, *, / und % funktionieren mit jedem numerischen Typ. Der Typ des Ergebnisses folgt den Operanden: Zwei int-Werte ergeben ein int, ein int und ein double ergeben ein 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
    }
}

Ausgabe:

22
12
85
3
2
3.4
3.4
3
3.4

Die Ganzzahldivision schneidet in Richtung null ab. 17 / 5 ist 3 und -17 / 5 ist -3. Das verursacht einen sehr häufigen Bug: int percent = done / total * 100; ist 0, solange done < total gilt, weil done / total bereits 0 ist. Multipliziere zuerst (done * 100 / total) oder dividiere als double.

Eine Ganzzahl oder ein decimal durch null zu teilen wirft DivideByZeroException. Ein double durch null zu teilen wirft nichts; es ergibt Unendlich, oder NaN bei 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");
        }
    }
}

Ausgabe:

True
True
False
DivideByZeroException

Der Modulo-Operator und negative Zahlen

% gibt den Rest der Division zurück, und das Ergebnis übernimmt das Vorzeichen des linken Operanden. Das unterscheidet sich von Python und vom mathematischen „mod“, die bei positivem Divisor nie negativ sind:

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

Ausgabe:

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

Nimm die Hilfsmethode Mod, wann immer die linke Seite negativ sein kann und das Ergebnis ein Index ist: days[(today + offset) % 7] würde bei einer negativen Summe eine IndexOutOfRangeException werfen. Der Test auf ungerade Zahlen hat dieselbe Falle: n % 2 == 1 ist für negative ungerade Zahlen false; prüfe n % 2 != 0.

Zuweisung, zusammengesetzte Zuweisung und Inkrement

= weist zu. Die zusammengesetzten Formen +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= verbinden eine Operation mit einer Zuweisung. ++ und -- addieren oder subtrahieren 1 und gibt es als Präfix- und Postfixform, die sich im zurückgegebenen Wert unterscheiden:

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

Ausgabe:

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

Der Fall mit byte zeigt eine Eigenheit: level = level + 10; kompiliert nicht, weil byte + int ein int ist, aber level += 10; kompiliert, weil die zusammengesetzte Zuweisung einen impliziten Cast zurück in den Typ der Variable enthält. Dieser Cast springt bei einem Überlauf um (aus 250 + 10 wird 4).

Vergleichsoperatoren und logische Operatoren

Vergleichsoperatoren (==, !=, <, >, <=, >=) geben ein bool zurück. Bei Strings vergleicht == den Text, nicht die Referenzen. Die logischen Operatoren sind ! (nicht), && (und), || (oder) und ^ (exklusives Oder).

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

Ausgabe:

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

&& und || werten kurzgeschlossen aus: Der rechte Operand läuft nur, wenn er das Ergebnis ändern kann. Genau das macht user != null && user.IsActive sicher. Die einfachen & und | werten bei Booleans immer beide Seiten aus, was in einer Bedingung selten gewollt ist.

Bitweise Operatoren und Verschiebeoperatoren

Bei Ganzzahltypen arbeiten &, |, ^ und ~ auf einzelnen Bits, und << und >> verschieben sie. Sie werden für Flags, Masken, Hashing und Low-Level-Protokolle verwendet:

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

Ausgabe:

3
True
False
101
1024
125
5
-1

Für benannte Mengen von Flags ist ein Enum mit dem Attribut [Flags] klarer als Ganzzahlkonstanten, und HasFlag liest sich besser als eine Maske. C# 11 hat >>> hinzugefügt, eine vorzeichenlose Rechtsverschiebung, die auch bei negativen Zahlen mit Nullen auffüllt.

Null-Operatoren

Für Werte, die null sein können, gibt es drei Operatoren:

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

Ausgabe:

Guest

0
5

a ?? b gibt a zurück, außer es ist null, dann b. a?.Member gibt null zurück, statt zu werfen, wenn a null ist. C# 8 hat a ??= b hinzugefügt, das a nur dann b zuweist, wenn a null ist. Ausführlich behandelt werden sie unter Nullable-Typen.

Rangfolge der Operatoren

Wenn ein Ausdruck Operatoren mischt, binden höhere Zeilen stärker. Operatoren in derselben Zeile gruppieren von links nach rechts, außer Zuweisung, ?? und ?:, die von rechts nach links gruppieren. (Die Operanden selbst werden immer von links nach rechts ausgewertet.)

Zwei Folgen, die du kennen solltest: a + b * c multipliziert zuerst, und x & mask == 0 vergleicht zuerst (== bindet stärker als &), bedeutet also x & (mask == 0) und kompiliert für Ganzzahlen nicht. Schreibe (x & mask) == 0. Klammern kosten nichts und machen die Absicht offensichtlich.

Operatorüberladung

Deine eigenen Typen können festlegen, was Operatoren bedeuten. So unterstützen decimal, DateTime und TimeSpan die Operatoren + und <:

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

Ausgabe:

33.49
True

Operatoren müssen public static sein, und manche gibt es nur als Pflichtpaar: Wer < definiert, muss auch > definieren, und zu == gehört !=. Ist == definiert, warnt der Compiler außerdem, bis du Equals und GetHashCode passend überschreibst. Überlade Operatoren nur dort, wo die Bedeutung offensichtlich ist, etwa bei Zahlen, Vektoren und Geld.