Indexers & Operator Overloading

public class WeekSchedule {
  private readonly string[] _days = new string[7];
  public string this[int dayIndex] {
    get => _days[dayIndex];
    set => _days[dayIndex] = value;
  }
}
var schedule = new WeekSchedule();
schedule[0] = "Meeting";
Console.WriteLine(schedule[0]); // "Meeting"

Common follow-ups: Can an indexer accept a non-integer parameter type, like a string, the way Dictionary does?

public struct Money {
  public decimal Amount;
  public static Money operator +(Money a, Money b) => new Money { Amount = a.Amount + b.Amount };
}
Money total = new Money { Amount = 10 } + new Money { Amount = 5 };
Console.WriteLine(total.Amount); // 15

Common follow-ups: Why must operator overloads always be declared as 'public static' members?

public static Vector operator +(Vector a, Vector b) => new(a.X + b.X, a.Y + b.Y); // OK
public static Vector operator *(Vector v, double scalar) => new(v.X * scalar, v.Y * scalar); // OK
// public static Vector operator &&(Vector a, Vector b) { } // NOT directly overloadable

Common follow-ups: How would you make a custom type work correctly with '&&' indirectly, given it can't be overloaded directly?

public struct Money : IComparable<Money> {
  public decimal Amount;
  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 int CompareTo(Money other) => Amount.CompareTo(other.Amount); // must agree with < and >
}

Common follow-ups: If you overload '<', does C# require you to also overload '>' — and what other operator pairing rules exist?

public struct Fahrenheit {
  public double Degrees;
  public static implicit operator Fahrenheit(double degrees) => new Fahrenheit { Degrees = degrees };
  public static explicit operator double(Fahrenheit f) => f.Degrees; // requires (double)fahrenheitValue
}
Fahrenheit temp = 98.6; // implicit conversion from double
double raw = (double)temp; // explicit conversion required

Common follow-ups: Why should a LOSSY or potentially-failing conversion always be marked 'explicit' rather than 'implicit'?

public class Matrix {
  private readonly double[,] _data;
  public Matrix(int rows, int cols) { _data = new double[rows, cols]; }
  public double this[int row, int col] {
    get => _data[row, col];
    set => _data[row, col] = value;
  }
}
var m = new Matrix(3, 3);
m[0, 1] = 5.0;

Common follow-ups: How would you additionally support a RANGE-based indexer, like matrix[0..2, ..] for slicing?

public struct OptionalValue {
  public bool HasValue;
  public static bool operator true(OptionalValue v) => v.HasValue;
  public static bool operator false(OptionalValue v) => !v.HasValue;
}
OptionalValue opt = new OptionalValue { HasValue = true };
if (opt) { Console.WriteLine("Has a value!"); } // works, thanks to the true/false operators

Common follow-ups: Why must you overload BOTH true and false together, and never just one alone?

public readonly struct Vector3 {
  public readonly double X, Y, Z;
  public Vector3(double x, double y, double z) { X = x; Y = y; Z = z; }
  public static Vector3 operator +(Vector3 a, Vector3 b) => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
  public static Vector3 operator *(Vector3 v, double scalar) => new(v.X * scalar, v.Y * scalar, v.Z * scalar);
}
Vector3 result = (v1 + v2) * 2.0; // fully chainable, zero heap allocation

Common follow-ups: Why is 'readonly struct' specifically recommended here, beyond just 'struct'?

public struct SafeInt {
  public int Value;
  public static SafeInt operator +(SafeInt a, SafeInt b) => new SafeInt { Value = a.Value + b.Value }; // unchecked
  public static SafeInt operator checked +(SafeInt a, SafeInt b) =>
    new SafeInt { Value = checked(a.Value + b.Value) }; // throws OverflowException if it overflows
}

Common follow-ups: In what scenario would the compiler automatically choose the checked overload over the regular one?

public class CircularBuffer<T> : IEnumerable<T> {
  private readonly T[] _items;
  public T this[int index] => _items[index % _items.Length]; // wraps around
  public CircularBuffer(int size) { _items = new T[size]; }
  public IEnumerator<T> GetEnumerator() {
    foreach (var item in _items) yield return item;
  }
  IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

Common follow-ups: What's the difference between implementing the generic IEnumerable<T> versus only the non-generic IEnumerable?