Mutable or immutable types: how do you decide in a C# system? Explain the benefits and costs of immutability, the C# tools for it (readonly, init, records, immutable and frozen collections), the difference between read-only and immutable, and where mutability is still the right choice.

1. Immutability and the memory model

In .NET, an object published to other threads through a field write can be observed before its constructor's writes are visible on weakly ordered CPUs (Arm64) unless publication is safe. In practice the CLR's memory model (and x64's strong ordering) makes most patterns safe, but for lock-free publication use Volatile.Write/Interlocked.Exchange when swapping references, and Volatile.Read when reading. Immutable objects are safe once safely published — there's no later mutation to race with.

2. Structural sharing

ImmutableList<T> and ImmutableDictionary<K,V> are balanced trees; an update creates O(log n) new nodes and reuses the rest, so keeping many versions is cheap. ImmutableArray<T> is a thin wrapper over an array — O(1) reads, O(n) copy on change — best for read-heavy, rarely changed data. Builders (ToBuilder(), CreateBuilder()) batch many changes efficiently.

3. Atomic updates of shared immutable state

private ImmutableDictionary<string, Rate> _rates = ImmutableDictionary<string, Rate>.Empty;

public void Update(string key, Rate rate) =>
    ImmutableInterlocked.AddOrUpdate(ref _rates, key, rate, (_, _) => rate);   // CAS loop

Readers use the current snapshot without locks; writers retry if another writer intervened. For whole-table refreshes, build a new frozen dictionary and Interlocked.Exchange the reference.

4. Records and invariants

with expressions bypass constructors; to keep invariants on immutable records, validate in init accessors (C# 14 field keyword) or keep properties get-only and expose factory methods that validate. Immutable doesn't automatically mean valid.

5. Immutability in architecture

• Events and messages are immutable facts — records are a natural fit.
• Event sourcing: state is derived by applying immutable events; the aggregate may be mutable in memory but the history isn't.
• Configuration: IOptionsSnapshot<T> (per request) and IOptionsMonitor<T> (with change notifications) provide snapshot semantics.
• Caching: immutable cached values avoid defensive copying.
• Functional core, imperative shell: pure functions over immutable data at the core, side effects at the edges.

6. Measuring the cost

If immutable updates are in a hot path, measure allocations with BenchmarkDotNet and dotnet-counters. Common fixes: batch changes with builders, use ImmutableArray for read-heavy data, or use mutable structures locally and freeze at the end.

Try it yourself

1. Expose a List<T> as IReadOnlyList<T>, mutate the list, and observe the "read-only" view change.
2. Build a FrozenDictionary refresh with an atomic swap and hammer it from many threads.
3. Benchmark adding 10,000 items to ImmutableList one by one vs via a builder.
4. Write a record with a validating init accessor and try to bypass it with with.

// Immutable configuration snapshot swapped atomically
public sealed class TaxRuleProvider(ITaxRuleStore store, ILogger<TaxRuleProvider> log)
{
    private FrozenDictionary<string, TaxRule> _rules = FrozenDictionary<string, TaxRule>.Empty;

    public TaxRule? For(string region) =>
        Volatile.Read(ref _rules).GetValueOrDefault(region);

    public async Task RefreshAsync(CancellationToken ct)
    {
        var latest = await store.LoadAllAsync(ct);
        var snapshot = latest.ToFrozenDictionary(r => r.Region, StringComparer.OrdinalIgnoreCase);
        Volatile.Write(ref _rules, snapshot);          // readers see old or new, never partial
        log.LogInformation("Loaded {Count} tax rules", snapshot.Count);
    }
}

// Immutable value with validated creation
public sealed record TaxRule(string Region, decimal Rate)
{
    public decimal Rate { get; init; } = Rate is >= 0 and <= 1 ? Rate
        : throw new ArgumentOutOfRangeException(nameof(Rate));
}

// Controlled mutability in an entity
public sealed class Order
{
    private readonly List<OrderLine> _lines = [];
    public IReadOnlyList<OrderLine> Lines => _lines;      // read-only VIEW, not immutable
    public OrderStatus Status { get; private set; }

    public void AddLine(OrderLine line)
    {
        if (Status != OrderStatus.Draft) throw new InvalidOperationException("Order is locked");
        _lines.Add(line);
    }
}

// Builder: mutate locally, publish immutable
var builder = ImmutableArray.CreateBuilder<string>(initialCapacity: 100);
foreach (var row in rows) builder.Add(row.Trim());
ImmutableArray<string> cleaned = builder.ToImmutable();