What is a ref struct and when would you write one? Explain the rules (stack-only, no boxing, no class fields, no lambda capture), ref fields (C# 11), C# 13 changes (implementing interfaces, the allows ref struct anti-constraint, use in async and iterator methods), the Dispose pattern for ref structs, and walk through a ValueStringBuilder-style type.

How I would answer this in an interview

A ref struct is a value type that must live on the stack. That restriction lets it safely hold managed references (ref fields) into the stack, arrays or native memory — which is how Span<T>, ReadOnlySpan<T>, Utf8JsonReader and ValueStringBuilder work. I'd cover the rules, ref fields, C# 13 changes, the Dispose pattern, and walk through a ValueStringBuilder-style type.

1. The rules

A ref struct:

• Can't be boxed (no conversion to object, ValueType, or — before C# 13 — interfaces).
• Can't be a field of a class or a normal struct (only of another ref struct).
• Can't be captured by lambdas or local functions that become delegates.
• Can't be used across await or yield (C# 13 allows them in async/iterator methods if they don't cross a suspension point).
• Can't be an array element or (before C# 13) a generic type argument.
• Is subject to ref safety rules (the compiler prevents returning a ref struct that refers to stack memory of the current method).

These rules guarantee a ref struct never outlives the stack frame of the memory it may reference.

2. ref fields (C# 11)

public readonly ref struct Slice<T>
{
    private readonly ref T _first;
    private readonly int _length;
    public Slice(ref T first, int length) { _first = ref first; _length = length; }
    public int Length => _length;
}

Only ref structs can declare ref fields. Combined with scoped and the updated safety rules, they let you build span-like abstractions in C# (the BCL's Span<T> now uses a real ref T field).

3. C# 13 changes

• Interfaces: ref structs can implement interfaces (e.g. IDisposable, IEnumerator<T>), but still can't be converted to the interface (no boxing). The interfaces are usable via generics.
• allows ref struct anti-constraint: generic methods/types can opt in to accepting ref structs: void Process<T>(T value) where T : allows ref struct. The compiler then enforces ref-struct rules for T inside. .NET 9 annotated many BCL generics (Func<>, Action<>, some collections/comparers) so spans can flow through them.
• Async and iterator methods can declare ref struct locals (e.g. Span<T>) as long as they're not used across await/yield.

4. Dispose pattern for ref structs

ref structs can't implement IDisposable usefully in older versions, so using is pattern-based: any ref struct with an accessible void Dispose() method works in a using statement/declaration. Typical use: returning a rented ArrayPool buffer.

5. A ValueStringBuilder-style type

public ref struct ValueStringBuilder
{
    private char[]? _rented;
    private Span<char> _buffer;
    private int _length;

    public ValueStringBuilder(Span<char> initialBuffer)
    {
        _rented = null;
        _buffer = initialBuffer;
        _length = 0;
    }

    public void Append(char c)
    {
        if (_length == _buffer.Length) Grow(1);
        _buffer[_length++] = c;
    }

    public void Append(scoped ReadOnlySpan<char> s)
    {
        if (_length + s.Length > _buffer.Length) Grow(s.Length);
        s.CopyTo(_buffer[_length..]);
        _length += s.Length;
    }

    public void Append<T>(T value, ReadOnlySpan<char> format = default) where T : ISpanFormattable
    {
        int written;
        while (!value.TryFormat(_buffer[_length..], out written, format, CultureInfo.InvariantCulture))
            Grow(16);
        _length += written;
    }

    private void Grow(int additional)
    {
        var newArray = ArrayPool<char>.Shared.Rent(Math.Max(_buffer.Length * 2, _length + additional));
        _buffer[.._length].CopyTo(newArray);
        var toReturn = _rented;
        _buffer = _rented = newArray;
        if (toReturn is not null) ArrayPool<char>.Shared.Return(toReturn);
    }

    public override string ToString()
    {
        var result = new string(_buffer[.._length]);
        Dispose();
        return result;
    }

    public void Dispose()
    {
        var toReturn = _rented;
        this = default;                                   // prevent double return / use after dispose
        if (toReturn is not null) ArrayPool<char>.Shared.Return(toReturn);
    }
}

// Usage: starts on the stack, grows into pooled arrays only if needed
var sb = new ValueStringBuilder(stackalloc char[256]);
sb.Append("Order "); sb.Append(orderId); sb.Append(" total "); sb.Append(total, "C2");
string text = sb.ToString();

Why it's a ref struct: it holds a Span<char> that may point to stack memory (stackalloc), so it must not escape. The BCL uses an internal ValueStringBuilder like this for zero-allocation formatting; DefaultInterpolatedStringHandler is a public ref struct built on the same idea.

6. When I'd write one

• Low-level buffer builders/readers (parsers, formatters, protocol encoders).
• Wrappers over spans that add domain-specific reading/writing (SequenceReader-style).
• Interpolated string handlers (must be ref structs).
• Scoped helpers that must not escape (e.g. a struct holding a lock or pooled resource, disposed in the same frame).

Not for business logic, async workflows, or anything that needs to be stored or passed through interfaces.

7. A production example

A high-volume CSV export built each line with StringBuilder and ToString() per row. We introduced a ValueStringBuilder starting from stackalloc char[512], formatting numbers with TryFormat and writing the resulting span directly to a StreamWriter (no intermediate string). Allocations per row dropped to zero for typical rows, and the rare long rows fell back to pooled arrays. We added tests for double-dispose and growth paths because bugs in such types corrupt data silently.