IReadOnly

TL;DR

IReadOnlyCollection<T> and IReadOnlyList<T> expose Count (and indexed access in the latter) without surfacing Add, Remove, or Clear, so callers can read and iterate but can't mutate your internal state. List<T> already implements both interfaces, so the cast is free — no defensive .ToList() copy needed. They don't guarantee true immutability though: wrap with ReadOnlyCollection<T> or use ImmutableList<T> when the backing store must never change.

How it works

IReadOnlyCollection & IReadOnlyList — Immutable Access

"Use IReadOnly* interfaces to expose collections without allowing modification."

❌ Bad example:

public class Portfolio
{
    private List<Position> _positions = new();

    public List<Position> Positions => _positions; // exposes internal list
}

// Caller can mutate internal state
var portfolio = new Portfolio();
portfolio.Positions.Add(new Position()); // breaks encapsulation
portfolio.Positions.Clear(); // disaster!

Exposing mutable collections lets callers break invariants and bypass validation.

✅ Good example:

public class Portfolio
{
    private List<Position> _positions = new();

    public IReadOnlyCollection<Position> Positions => _positions;

    public void AddPosition(Position position)
    {
        ValidatePosition(position);
        _positions.Add(position);
    }
}

// Caller can only read
var portfolio = new Portfolio();
int count = portfolio.Positions.Count; // ✅ allowed
// portfolio.Positions.Add(...); // ❌ compiler error

👉 IReadOnlyCollection provides Count and iteration, but no Add/Remove.

🔥 Using IReadOnlyList for indexed access:

public class TradingDay
{
    private List<Trade> _trades = new();

    public IReadOnlyList<Trade> Trades => _trades;

    public void RecordTrade(Trade trade)
    {
        _trades.Add(trade);
    }
}

// Caller can access by index, but not modify
var day = new TradingDay();
var firstTrade = day.Trades[0]; // ✅ indexed access
int count = day.Trades.Count;   // ✅ count
// day.Trades.Add(...);          // ❌ compiler error

👉 IReadOnlyList adds indexed access without exposing mutability.

🔥 Avoiding defensive copies:

// ❌ Bad: creates unnecessary copy
public IEnumerable<Order> GetOrders()
{
    return _orders.ToList(); // allocates new list every call
}

// ✅ Good: exposes read-only view without copying
public IReadOnlyCollection<Order> GetOrders()
{
    return _orders; // no allocation, just interface cast
}

👉 List implements IReadOnlyCollection, so casting is free.

💡 In trading systems:

• Expose position snapshots as IReadOnlyCollection to prevent accidental modifications.
• Return IReadOnlyList for price history where indexed access is useful.
• Prevent invariant violations by hiding Add/Remove while keeping data accessible.

Quick recall Q&A