What does readonly mean in each place it can appear in C#? Explain readonly fields, static readonly versus const (and the versioning trap), readonly structs, readonly members, readonly ref returns, how the JIT treats static readonly values, and why readonly does not make an object immutable.

How I would answer this in an interview

readonly means "can't be reassigned after initialisation", but what is read-only depends on where it appears: a field, a struct, a struct member, or a reference returned by ref readonly. The common thread is that readonly protects a storage location, not the object graph behind it. I'd go through each place, static readonly vs const (and the versioning trap), how the JIT treats static readonly, and why readonly isn't immutability.

1. readonly fields

public sealed class OrderService(IOrderRepository repo)
{
    private readonly IOrderRepository _repo = repo;          // assign once
    private readonly List<string> _audit = [];                // reference can't change...
    public void Note(string s) => _audit.Add(s);              // ...but the list's contents can
}

• Can be assigned in the declaration, constructors (of the same type), or init accessors.
• After construction, reassignment is a compile error (CS0191).
• Reflection (FieldInfo.SetValue) can still change it (and static readonly writes via reflection are blocked/undefined in modern runtimes after initialisation) — it's a language guarantee, not a security boundary.

2. static readonly vs const (the versioning trap)

The versioning trap: public const int MaxPageSize = 50; in a NuGet package — changing it to 100 does nothing for consumers compiled against v1. Use const for true constants (BitsPerByte) or non-public values; use static readonly (or a property) for public values that may change.

3. How the JIT treats static readonly

With tiered compilation, hot methods are recompiled at tier 1 after the type's static constructor has run. The JIT then knows the actual value of static readonly fields and treats them as constants:

private static readonly bool s_verbose = Environment.GetEnvironmentVariable("VERBOSE") == "1";
if (s_verbose) Log(...);   // at tier 1, the whole branch can be eliminated when false

This also applies to static readonly object references (devirtualising calls on them) and primitive values (constant folding). So static readonly usually performs like const in steady state, while staying configurable.

4. readonly struct

public readonly struct Money(decimal amount, string currency)
{
    public decimal Amount { get; } = amount;
    public string Currency { get; } = currency;
}

• All instance fields must be readonly; auto-properties must be get-only or init.
• The compiler knows no member mutates this, so it skips defensive copies when the struct is accessed via in parameters, readonly fields or ref readonly refs.
• Communicates intent: a value type that never changes.

5. readonly members (C# 8)

public struct Counter
{
    public int Value;
    public readonly int Doubled() => Value * 2;   // promises not to mutate
    public void Increment() => Value++;
}

For mutable structs, marking non-mutating members readonly avoids defensive copies when called on read-only locations. The compiler rejects mutations inside readonly members.

6. ref readonly returns (and locals)

private Matrix4x4 _transform;
public ref readonly Matrix4x4 Transform => ref _transform;   // no 64-byte copy; caller can't modify

ref readonly var t = ref obj.Transform;

Returns a reference to storage without allowing writes through it — cheap access to large structs. If the struct isn't readonly, member calls through t may still cause defensive copies.

7. Why readonly doesn't make an object immutable

• A readonly field holding a reference type prevents reassigning the reference, but the referenced object (a List<T>, a mutable entity, an array) can still change.
• readonly arrays: private static readonly int[] Primes = {2, 3, 5}; — anyone with access can do Primes[0] = 99.
• A readonly struct containing a reference to a mutable object is only shallowly immutable.
• Exposing a readonly field as a public IReadOnlyList<T> view still allows casting back.

For real immutability: immutable types all the way down (records with init, ImmutableArray<T>, FrozenSet<T>, ReadOnlySpan<T> static properties for constant data, string).

8. A production example

A rules service exposed public static readonly string[] AllowedCountries = { "AU", "NZ" }; A feature for a pilot in Singapore did AllowedCountries[1] = "SG" at start-up "temporarily" — and New Zealand customers were rejected for a day. Changing it to public static readonly FrozenSet<string> AllowedCountries = new[] { "AU", "NZ" }.ToFrozenSet(StringComparer.OrdinalIgnoreCase); made mutation impossible and lookups faster; the pilot got proper configuration.