When should you use `ReadOnlySpan<T>` instead of `Span<T>`, and what modern features build on it? Explain read-only views over strings and constant data, u8 literals, static ReadOnlySpan properties backed by assembly data, SearchValues, overload preference, and the C# 14 first-class span conversions.

How I would answer this in an interview

Use ReadOnlySpan<T> whenever code only reads the data — which is most of the time. It accepts more sources (strings, constant data, read-only memory, ImmutableArray<T>), documents intent, prevents accidental writes, and unlocks compiler optimisations. Use Span<T> only when the method must write into the buffer. I'd cover read-only views over strings and constant data, u8 literals, static ReadOnlySpan<byte> properties, SearchValues, overload preference, and C# 14's first-class span conversions.

1. Read-only views over strings

static bool IsValidPostcode(ReadOnlySpan<char> s) => s.Length == 4 && s.IndexOfAnyExceptInRange('0', '9') < 0;

IsValidPostcode("2000");                 // string -> ReadOnlySpan<char>, no allocation
IsValidPostcode(input.AsSpan(5, 4));     // slice of a larger string
IsValidPostcode(charArray);              // char[] works too

Strings are immutable, so they can only be viewed as ReadOnlySpan<char> — a method taking Span<char> couldn't accept a string at all. Accepting ReadOnlySpan<char> makes an API work with strings, arrays, stack buffers and slices.

2. Constant data, u8 literals and static properties

ReadOnlySpan<byte> contentType = "application/json"u8;     // UTF-8 bytes baked into the assembly

private static ReadOnlySpan<byte> PngSignature => [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
private static ReadOnlySpan<char> Hex => "0123456789ABCDEF";

• A static ReadOnlySpan<byte> property returning a constant array/collection expression of primitives compiles to a span pointing directly into the assembly's data section — no allocation, no static array, no initialisation. (It must be a property returning ReadOnlySpan<T>, not a field, because spans can't be stored in static fields.) Since .NET 7/C# 11 this works for all primitive element types (with correct endianness handling), not just bytes.
• "..."u8 literals (C# 11) produce ReadOnlySpan<byte> UTF-8 data at compile time — ideal for HTTP headers, JSON property names with Utf8JsonWriter, protocol constants.
• These are read-only by necessity: the memory is part of the loaded image.

3. SearchValues

private static readonly SearchValues<char> CsvSpecial = SearchValues.Create(",\"\r\n");
private static readonly SearchValues<string> BannedWords = SearchValues.Create(["drop", "delete"], StringComparison.OrdinalIgnoreCase);  // .NET 9

bool needsQuoting = value.AsSpan().ContainsAny(CsvSpecial);
int index = text.AsSpan().IndexOfAny(BannedWords);

SearchValues (.NET 8) precomputes an optimised, often vectorised strategy for repeated searches over ReadOnlySpan<T> — much faster than naive loops or IndexOfAny(char[]) for repeated use. Store them in static readonly fields.

4. Overload preference

When APIs have overloads for string, T[], ReadOnlySpan<T> and Span<T>:

• Passing an array or span to an API with both Span<T> and ReadOnlySpan<T> overloads picks the read-only one when the method only reads (API authors usually provide just ReadOnlySpan<T> for input).
• Collection expressions and params ReadOnlySpan<T> (C# 13) prefer span overloads, avoiding array allocations.
• [OverloadResolutionPriority] (C# 13) lets library authors steer callers to new span overloads without breaking existing ones.

API guideline: input buffers → ReadOnlySpan<T>, output buffers → Span<T> (with a TryXxx(..., out int written) pattern).

5. C# 14 first-class span conversions

Before C# 14, spans weren't first-class in the type system: conversions like T[] → ReadOnlySpan<T> were user-defined implicit operators, so they didn't work for extension method receivers, type inference or some generic scenarios:

int[] numbers = [1, 2, 3];
numbers.ContainsAny(...)    // MemoryExtensions on ReadOnlySpan<T> - previously needed .AsSpan()

C# 14 adds implicit span conversions recognised by the language: T[] → Span<T>/ReadOnlySpan<T>, Span<T> → ReadOnlySpan<T>, string → ReadOnlySpan<char>, including covariant conversions for reference-type elements (string[] → ReadOnlySpan<object>). These participate in extension method lookup and generic type inference, so span-based extension methods work directly on arrays and strings, and overload resolution prefers span overloads more consistently. (Some existing code saw overload changes — e.g. Enumerable vs MemoryExtensions methods on arrays — which the .NET team mitigated with priorities.)

6. A production example

An HTTP middleware compared request header values with strings and wrote constant headers via Encoding.UTF8.GetBytes("...") per request. Converting constants to "..."u8 and static ReadOnlySpan<byte> properties, header checks to ReadOnlySpan<char> with SearchValues, and the API signatures to accept ReadOnlySpan<char> removed per-request allocations from the middleware and made the code accept slices without copying.