How does operator overloading work in C#? Explain the rules for declaring operators, which operators come in pairs, equality operators and Equals, conversion operators, checked operators, generic math interfaces, and C# 14 user-defined compound assignment operators.

How I would answer this in an interview

Operator overloading lets a type define what operators like +, == or < mean for its instances. It's valuable for value-like types where the operator meaning is obvious (Money + Money, Vector * scalar, Duration < Duration) and harmful anywhere the meaning would surprise. I'd cover the declaration rules, paired operators, equality, conversions, checked operators, generic math, and C# 14's compound assignment operators.

1. Declaration rules

public readonly record struct Money(decimal Amount, string Currency)
{
    public static Money operator +(Money a, Money b)
    {
        if (a.Currency != b.Currency) throw new InvalidOperationException("Currency mismatch");
        return new(a.Amount + b.Amount, a.Currency);
    }
    public static Money operator -(Money a) => a with { Amount = -a.Amount };   // unary
    public static Money operator *(Money a, decimal factor) => a with { Amount = a.Amount * factor };
    public static bool operator <(Money a, Money b) => Compare(a, b) < 0;
    public static bool operator >(Money a, Money b) => Compare(a, b) > 0;
    private static int Compare(Money a, Money b) { /* currency check */ return a.Amount.CompareTo(b.Amount); }
}

• Operators are public static methods using the operator keyword.
• At least one parameter must be the containing type (you can't redefine int + int).
• You can overload unary (+ - ! ~ ++ -- true false), binary arithmetic/bitwise/shift (+ - * / % & | ^ << >> >>>), comparison (== != < > <= >=) and conversion operators.
• You can't overload &&, || (derived from &/| plus true/false), =, ., ?:, ??, =>, new, is, as, typeof; and compound assignment like += historically was derived from + (until C# 14 — see below).
• Overloads are resolved at compile time from static types (operators are not virtual).

2. Operators that must come in pairs

The compiler requires these pairs: ==/!=, </>, <=/>=, and true/false. Defining one without its partner is an error (CS0216).

3. Equality operators and Equals

If you overload ==/!=, you must keep them consistent with Equals(object), IEquatable<T>.Equals and GetHashCode (the compiler warns CS0660/CS0661). Typical pattern:

public static bool operator ==(Sku? a, Sku? b) => a?.Equals(b) ?? b is null;
public static bool operator !=(Sku? a, Sku? b) => !(a == b);

Records generate all of these consistently, which is one reason to use them for value types. Overloading == on mutable reference types is usually a mistake — developers expect reference equality from == on classes.

4. Conversion operators

public readonly record struct Abn(string Value)
{
    public static explicit operator Abn(string s) => Parse(s);     // may fail -> explicit
    public static implicit operator string(Abn abn) => abn.Value;  // always safe -> implicit
}

Rules: implicit only when the conversion can't fail and loses no information; otherwise explicit. Too many implicit conversions make overload resolution confusing and hide bugs (silently converting an OrderId to a Guid defeats strongly typed IDs).

5. Checked operators (C# 11)

public static Quantity operator +(Quantity a, Quantity b) => new(unchecked(a.Value + b.Value));
public static Quantity operator checked +(Quantity a, Quantity b) => new(checked(a.Value + b.Value));

In a checked context the checked version is used, so user types can participate in overflow checking like built-in numeric types.

6. Generic math interfaces (.NET 7)

Operators can be static abstract interface members, so generic code can use them:

public readonly record struct Money(decimal Amount) :
    IAdditionOperators<Money, Money, Money>, IAdditiveIdentity<Money, Money>
{
    public static Money operator +(Money a, Money b) => new(a.Amount + b.Amount);
    public static Money AdditiveIdentity => new(0m);
}

static T Sum<T>(IEnumerable<T> items) where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
{
    var total = T.AdditiveIdentity;
    foreach (var i in items) total += i;
    return total;
}

7. C# 14 user-defined compound assignment

Previously a += b always compiled to a = a + b — for reference types that means allocating a new object. C# 14 lets types define instance compound assignment operators (and ++/--) that mutate in place:

public sealed class Accumulator
{
    private decimal _total;
    public void operator +=(decimal value) => _total += value;   // in-place, no new object
}

Useful for large mutable types (big-number buffers, matrices, builders) where creating a new instance per operation is wasteful. If not defined, the old a = a + b lowering still applies.

8. A production example

A finance module used decimal everywhere for amounts, and a bug added an AUD amount to a USD amount in a multi-currency report. Introducing a Money record struct with +/- operators that throw on currency mismatch, comparison operators and no implicit conversion from decimal made such mixing a run-time failure in tests rather than a silent wrong total — and the code still read naturally (subtotal + shipping).