Explain the C# operators you use daily, including the null operators (?., ??, ??=), short-circuit evaluation, integer division and operator precedence. Where do they cause bugs?

1. What ?. and ?? compile to

?. evaluates the receiver once into a temporary, tests it, then continues:

// var city = order?.Customer?.City;
var t1 = order;
string? city;
if (t1 == null) city = null;
else
{
    var t2 = t1.Customer;
    city = t2 == null ? null : t2.City;
}

Because the receiver is evaluated once, GetOrder()?.Total calls GetOrder() only once. For value-type results the expression is lifted: order?.Total has type decimal?. That is why int count = list?.Count; does not compile and you need list?.Count ?? 0.

The null-conditional invocation handler?.Invoke(this, args) is the standard thread-safe event raise: the delegate is copied into a temporary before the null check, so another thread unsubscribing between the check and the call cannot cause an NRE.

a ?? b compiles to "evaluate a once; if not null use it (unwrapping Nullable<T> with GetValueOrDefault()), else evaluate b". The right side being lazily evaluated is what makes ?? throw legal — throw is an expression since C# 7.

2. Why ??= is not thread-safe

_cache ??= Load();
// is roughly
if (_cache is null) _cache = Load();

Two threads can both see null and both call Load(). For thread-safe lazy initialisation use Lazy<T>, LazyInitializer.EnsureInitialized, or Interlocked.CompareExchange(ref _cache, Load(), null) when duplicate creation is acceptable but you need one published winner.

3. Operator overload resolution is static

Operators are static methods resolved at compile time from the operands' static types:

string s1 = "hello";
string s2 = new string("hello".ToCharArray());
Console.WriteLine(s1 == s2);                 // True  - string.op_Equality
Console.WriteLine((object)s1 == (object)s2); // False - reference equality

The compiler warns (CS0252/CS0253) when you compare object with string this way. This is also why generic code where T : class comparing a == b uses reference equality even if T is string — use EqualityComparer<T>.Default.Equals(a, b) in generics.

is null compiles to a direct reference comparison, bypassing any user-defined ==. Some ORMs and Unity's UnityEngine.Object override == so that destroyed objects compare equal to null — that is the classic case where is null and == null disagree.

4. Short-circuit evaluation in IL

a && b becomes a branch: evaluate a; if false jump to "false" without evaluating b. a & b evaluates both and performs a bitwise AND. Short-circuiting is therefore also a performance tool: put the cheapest, most selective test first (if (span.Length > 0 && ExpensiveCheck(span))).

With bool?, the & (AND) and OR operators implement SQL-style three-valued logic:

5. Integer division, remainder and shifts at the CPU level

• x64 idiv truncates toward zero and produces both quotient and remainder; C# defines % to match, so the remainder takes the sign of the dividend.
• Division is one of the slowest integer instructions (tens of cycles). The JIT replaces division by a constant with multiply-and-shift, and x % 2^n for non-negative values can be x & (2^n - 1). Math.DivRem returns both results.
• int.MinValue / -1 overflows and throws OverflowException even in unchecked code, because the CPU faults.
• Shift counts are masked to 5 bits for 32-bit types and 6 bits for 64-bit, matching x86 hardware: x << 33 on an int equals x << 1.

6. Precedence and associativity rules worth memorising

• Assignment, ??, ??= and ?: are right-associative: a ?? b ?? c is a ?? (b ?? c), which is what you want.
• Everything else binary is left-associative: a - b - c is (a - b) - c.
• as and is sit with relational operators, so x as Foo ?? fallback works as expected, but !x is Foo parses as (!x) is Foo — write x is not Foo.
• Lambdas bind loosest of all, which is why Func<int,int> f = x => x + 1; needs no parentheses.

7. Pattern-based operators

Modern C# turns many operator combinations into patterns, which are easier to read and harder to get wrong:

if (order is { Status: OrderStatus.Paid, Total: > 0m }) { ... }
if (code is >= 200 and < 300) { ... }
if (input is not (null or "")) { ... }

Patterns are evaluated left to right with short-circuiting, and they do not call user-defined == for constant patterns on most types.

Try it yourself

1. In SharpLab, compile var x = a?.B?.C ?? 0; and read the lowered C#.
2. Print -7 / 2, -7 % 3, 1 << 32 and int.MinValue / -1 (in a try/catch).
3. Write decimal? price = null; decimal shipping = 5; var t = price ?? 0 + shipping; and print t, then add parentheses.
4. Compare (object)"ab" == (object)string.Concat("a", "b") with string.Equals.

namespace Basics;

public sealed class Address { public string? City { get; set; } }
public sealed class Customer { public Address? Address { get; set; } }
public sealed record Point(int X, int Y);

public static class OperatorDemo
{
    private static List<string>? _cache;

    public static void Main()
    {
        Customer? customer = null;

        // Null-conditional + null-coalescing
        string city = customer?.Address?.City ?? "Unknown";
        Console.WriteLine(city);                       // Unknown

        // C# 14 null-conditional assignment: no-op when customer is null
        customer?.Address = new Address { City = "Perth" };

        // ??= lazily initialises once
        _cache ??= ["a", "b"];

        // Integer division trap
        int processed = 1, total = 3;
        Console.WriteLine(processed / total * 100);                     // 0
        Console.WriteLine((int)Math.Round(100.0 * processed / total)); // 33

        // Modulo sign follows the dividend
        Console.WriteLine(-7 % 3);                     // -1
        Console.WriteLine(IsOdd(-7));                  // True

        // Precedence
        int? n = null;
        Console.WriteLine(n ?? 0 + 5);                 // 5  (n ?? (0 + 5))
        Console.WriteLine((n ?? 0) + 5);               // 5, but intent is now clear

        // Value equality on records, reference equality on classes
        Console.WriteLine(new Point(1, 2) == new Point(1, 2)); // True

        // Index and range
        int[] values = [10, 20, 30, 40];
        Console.WriteLine(values[^1]);                 // 40
        Console.WriteLine(string.Join(",", values[1..3])); // 20,30
    }

    private static bool IsOdd(int x) => x % 2 != 0;
}