C# Operators: Arithmetic, Modulo, Logical, Bitwise and Precedence

An operator takes one, two or three operands and produces a value: a + b, !done, x ?? fallback. C#'s operators are close to those of C, Java and JavaScript, but a few behave in ways that surprise newcomers, above all integer division and the sign of %.

Arithmetic operators

+, -, *, / and % work on every numeric type. The type of the result follows the operands: two int values produce an int, an int and a double produce a 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

Integer division truncates toward zero. 17 / 5 is 3 and -17 / 5 is -3. It causes a very common bug: int percent = done / total * 100; is 0 whenever done < total, because done / total is already 0. Multiply first (done * 100 / total) or divide as double.

Dividing an integer or decimal by zero throws DivideByZeroException. Dividing a double by zero does not throw; it produces infinity, or NaN for 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

The modulo operator and negative numbers

% returns the remainder of the division, and its result takes the sign of the left operand. This differs from Python and from the mathematical "mod", which are always non-negative for a positive divisor:

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

Use the Mod helper whenever the left side can be negative and the result is an index: days[(today + offset) % 7] would throw an IndexOutOfRangeException for a negative sum. Testing for odd numbers has the same trap: n % 2 == 1 is false for negative odd numbers; test n % 2 != 0.

Assignment, compound assignment and increment

= assigns. The compound forms +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= combine an operation with assignment. ++ and -- add or subtract 1, and come in prefix and postfix forms that differ in the value they return:

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

The byte case shows a quirk: level = level + 10; does not compile, because byte + int is an int, but level += 10; does, because compound assignment includes an implicit cast back to the variable's type. That cast wraps on overflow (250 + 10 becomes 4).

Comparison and logical operators

Comparison operators (==, !=, <, >, <=, >=) return a bool. For strings, == compares the text, not the references. The logical operators are ! (not), && (and), || (or) and ^ (exclusive or).

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

&& and || short-circuit: the right operand runs only when it can change the result. That is what makes user != null && user.IsActive safe. The single & and | on booleans always evaluate both sides, which is rarely what you want in a condition.

Bitwise and shift operators

On integer types, &, |, ^ and ~ work on individual bits, and << and >> shift them. They are used for flags, masks, hashing and low-level protocols:

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

For named sets of flags, an enum with the [Flags] attribute is clearer than integer constants, and HasFlag reads better than a mask. C# 11 added >>>, an unsigned right shift that fills with zeros even for negative numbers.

Null operators

Three operators exist for working with values that may be 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 returns a unless it is null, then b. a?.Member returns null instead of throwing when a is null. C# 8 added a ??= b, which assigns b to a only when a is null. These are covered in depth in nullable types.

Operator precedence

When an expression mixes operators, higher rows bind tighter. Operators in the same row group left to right, except assignment, ?? and ?:, which group right to left. (Operands themselves are always evaluated left to right.)

Two consequences worth knowing: a + b * c multiplies first, and x & mask == 0 compares first (== binds tighter than &), so it means x & (mask == 0) and does not compile for integers. Write (x & mask) == 0. Parentheses cost nothing and make intent obvious.

Operator overloading

Your own types can define what operators mean. This is how decimal, DateTime and TimeSpan support + and <:

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

Operators must be public static, and some come in required pairs: defining < requires >, and == requires !=. With == defined, the compiler also warns until you override Equals and GetHashCode to match. Overload operators only where the meaning is obvious, as with numbers, vectors and money.