What is ReadOnlySpan<char>, and how does it let you parse and slice strings without allocating? Show a parser that uses it, and explain its limitations and when to use ReadOnlyMemory<char> instead.

1. What a span is in memory

public readonly ref struct ReadOnlySpan<T>
{
    internal readonly ref T _reference;   // a managed pointer (C# 11 ref field)
    private readonly int _length;
}

On 64-bit, a span is 16 bytes: a managed pointer to the first element plus an int length. The managed pointer can target:

• the inside of a heap object (a string's first character, an array element) — an interior pointer the GC understands and updates if the object moves;
• stack memory (stackalloc);
• native memory (new Span<byte>(void* ptr, length)).

Because it may point into the stack, the type must not escape the stack, hence ref struct.

2. Why slicing is free

span.Slice(start, length) is just pointer arithmetic plus a bounds check:

new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, start), length)

No allocation, no copy. The JIT treats span indexers as intrinsics, eliminating bounds checks in common loop shapes (for (int i = 0; i < span.Length; i++)), so span loops are as fast as array loops.

3. String → span conversion

string has an implicit conversion to ReadOnlySpan<char>, implemented by taking a reference to the string's first character (ref string.GetPinnableReference()). Since strings are immutable, a read-only view is safe. You can never get a writable Span<char> over a string without unsafe tricks — and you shouldn't.

Going back to a string (span.ToString() or new string(span)) allocates; do it once at the end, only for values you keep.

4. Ref safety rules (simplified)

The compiler tracks a safe-to-escape scope for every span:

• A span over a heap array or string: safe to return from the method.
• A span over stackalloc memory: only safe within the current method.
• Method parameters: assumed to be returnable unless marked scoped (C# 11), which restricts them to the method and allows callers to pass stack spans.

ReadOnlySpan<char> Bad()
{
    Span<char> buffer = stackalloc char[16];
    return buffer;          // CS8352: may expose stack memory outside its scope
}

These rules are what make spans memory-safe without a GC-tracked lifetime.

5. Memory<T> internals

public readonly struct ReadOnlyMemory<T>
{
    private readonly object? _object;   // string, T[], or MemoryManager<T>
    private readonly int _index;
    private readonly int _length;
}

Memory<T> stores an object reference, not a managed pointer, so it can live on the heap. Calling .Span inspects _object's type and builds a span — a small cost, so in loops get the span once outside the loop. MemoryManager<T> lets you wrap native or pooled memory (e.g. MemoryPool<T>.Shared.Rent), with an IMemoryOwner<T> that must be disposed to return the buffer.

6. Useful span APIs for text (.NET 8–10)

7. Async parsing pattern

Because spans can't cross await, async parsers read into a buffer, then process synchronously:

while (true)
{
    ReadResult result = await reader.ReadAsync(ct);
    ReadOnlySequence<byte> buffer = result.Buffer;
    while (TryReadLine(ref buffer, out var line))   // synchronous helper using spans
        ProcessLine(line);
    reader.AdvanceTo(buffer.Start, buffer.End);
    if (result.IsCompleted) break;
}

The synchronous helper uses spans freely; only ReadOnlySequence<byte>/Memory<T> cross the await.

Try it yourself

1. Benchmark line.Split(',') + decimal.Parse against the span parser above with [MemoryDiagnoser].
2. Try to store a ReadOnlySpan<char> in a class field and read the compiler error.
3. Write an async method that holds a span across await and read CS4007/CS4012.
4. Use SearchValues.Create(",;\t") with IndexOfAny to find delimiters and measure the speed-up.

using System.Globalization;

namespace Strings;

public readonly record struct SaleRow(DateOnly Date, string ProductCode, decimal Amount);

public static class SpanCsvParser
{
    private static readonly Dictionary<string, string> ProductCodes =
        new(StringComparer.Ordinal) { ["ORD-42"] = "ORD-42", ["ORD-77"] = "ORD-77" };

    // Parses "2026-10-23,ORD-42,199.95" with no intermediate strings
    public static bool TryParse(ReadOnlySpan<char> line, out SaleRow row)
    {
        row = default;
        Span<Range> parts = stackalloc Range[4];
        int count = line.Split(parts, ',', StringSplitOptions.TrimEntries);
        if (count != 3) return false;

        if (!DateOnly.TryParseExact(line[parts[0]], "yyyy-MM-dd", CultureInfo.InvariantCulture,
                                    DateTimeStyles.None, out var date))
            return false;

        if (!decimal.TryParse(line[parts[2]], NumberStyles.Number, CultureInfo.InvariantCulture, out var amount))
            return false;

        // .NET 9+: look up a string key by span, reuse the existing string instance
        var lookup = ProductCodes.GetAlternateLookup<ReadOnlySpan<char>>();
        if (!lookup.TryGetValue(line[parts[1]], out var code))
            return false;

        row = new SaleRow(date, code, amount);
        return true;
    }

    // ReadOnlyMemory<char> when slices must survive an await
    public static async Task<int> CountValidAsync(IAsyncEnumerable<ReadOnlyMemory<char>> lines, CancellationToken ct)
    {
        int valid = 0;
        await foreach (var line in lines.WithCancellation(ct))
        {
            if (TryParse(line.Span, out _)) valid++;   // .Span used synchronously, never across await
        }
        return valid;
    }

    public static void Main()
    {
        foreach (var text in new[] { "2026-10-23,ORD-42,199.95", "2026-10-23, ORD-77 , 5", "bad,line" })
        {
            Console.WriteLine(TryParse(text, out var row) ? row.ToString() : $"Rejected: {text}");
        }
    }
}