Span<T>, ReadOnlySpan<T> and Memory<T>

Reading the age out of 10,000 records such as “Asha,18,Pune” with string.Split allocated 150.1 bytes a record: an array and three new strings for every record, made only to be thrown away. Reading the same records through a spanspan: A Span<T> or ReadOnlySpan<T>: a view of a run of values that sit next to each other in memory, such as part of an array, which reads and writes them where they are. array.AsSpan(1, 3) refers to three elements of array and copies nothing. More in “Arrays, indices and ranges” allocated nothing at all.

A span is a view of memory that belongs to something else: part of an array, a string or the stack. This lesson shows the two span types, Span<T> and ReadOnlySpan<T>, which read and write such views in place, and Memory<T>Memory<T>: A struct that views a run of values in an array, a string or a pooled buffer, like a span, but can be stored in fields and kept across await. Its Span property gives a span for synchronous work., the view that code can keep in a field and use across await. You will slice without copying, pick the right type for code that waits, and parse text without allocating.

A span views memory it does not own, and copies nothing

views.cs slices an array, writes through the slice, then adds up the ages of 10,000 records in two ways:

// A span is a view: slicing copies nothing, writing through a span changes the memory it views, and a string can be
// read through a span without making new strings.
int[] marks = [41, 67, 88, 52, 73, 90, 35, 64];
Span<int> middle = marks.AsSpan(2, 4); // positions 2 to 5 of marks, not a copy
middle[0] = 99;                        // writes marks[2]
Console.WriteLine($"marks:  {string.Join(", ", marks)}");
Console.WriteLine($"middle: {middle.Length} values from position 2, first {middle[0]}, last {middle[^1]}");

string[] records = MakeRecords(10_000);
Console.WriteLine($"with Split: {BytesPerRecord(SumAgesWithSplit, records),5:F1} bytes a record, total {SumAgesWithSplit(records)}");
Console.WriteLine($"with spans: {BytesPerRecord(SumAgesWithSpans, records),5:F1} bytes a record, total {SumAgesWithSpans(records)}");

Span<char> digits = stackalloc char[11]; // a span over the stack: no heap at all
bool written = 41_250.TryFormat(digits, out int length);
Console.WriteLine($"stackalloc: {written}, {length} characters: {digits[..length]}");

// Adds up the ages of the records, reading each one with string.Split.
static long SumAgesWithSplit(string[] records)
{
    long total = 0;
    foreach (string record in records)
    {
        string[] fields = record.Split(','); // a new array and three new strings
        total += int.Parse(fields[1]);
    }
    return total;
}

// The same, reading each record through a ReadOnlySpan<char>.
static long SumAgesWithSpans(string[] records)
{
    long total = 0;
    foreach (string record in records)
    {
        ReadOnlySpan<char> line = record;
        ReadOnlySpan<char> rest = line[(line.IndexOf(',') + 1)..]; // after the name
        total += int.Parse(rest[..rest.IndexOf(',')]);             // up to the city
    }
    return total;
}

static double BytesPerRecord(Func<string[], long> sumAges, string[] records)
{
    sumAges(records); // warm up first, so that only the work itself is counted
    long before = GC.GetAllocatedBytesForCurrentThread();
    sumAges(records);
    return (GC.GetAllocatedBytesForCurrentThread() - before) / (double)records.Length;
}

static string[] MakeRecords(int count)
{
    string[] names = ["Asha", "Ravi", "Meera", "Kabir", "Ishaan", "Zoya"];
    string[] cities = ["Pune", "Kochi", "Indore", "Mysuru", "Guwahati"];
    var records = new string[count];
    for (int i = 0; i < count; i++) records[i] = $"{names[i % names.Length]},{18 + i % 50},{cities[i % cities.Length]}";
    return records;
}

marks:  41, 67, 99, 52, 73, 90, 35, 64
middle: 4 values from position 2, first 99, last 90
with Split: 150.1 bytes a record, total 425000
with spans:   0.0 bytes a record, total 425000
stackalloc: True, 5 characters: 41250

marks.AsSpan(2, 4) made no new array. The span holds a reference to marks[2] and a length of 4, so writing middle[0] wrote marks[2], which now holds 99. That is all a Span<T> is: a view of values that sit next to each other in memory, such as an array, part of one or memory from stackalloc, read and written in place. A ReadOnlySpan<T> is the same view without writing, and it is what a string gives you, because strings never change. Step through the program:

In the parse loop, Split made an array and three strings for every record, 150.1 bytes, while the span version found the commas with IndexOf, sliced, and gave the slice to int.Parse, which has an overload for spans: 0.0 bytes, for the same total.

Memory<T> is the view you can keep across await

A span cannot leave the stack. Span<T> is a ref structref struct: A struct declared with ref struct, such as Span<T>. Its instances live only on the stack: it cannot be boxed, be a field of a class, be captured by a lambda or be kept across an await. More in “ref structs, ref fields and scoped”, so a class cannot have a span field, and an async method cannot keep a span across an await, because its locals may move to the heap while it waits. Memory<T> and ReadOnlyMemory<T> view the same arrays and strings, or a buffer rented from a pool, but are ordinary structs, which can be stored anywhere; their Span property gives a span for the synchronous work in between. memory.cs keeps a read-only memory in a field and returns one line per await:

// Memory<T> can be kept in a field and used across await; .Span gives a span for the synchronous work in between.
var reader = new LineReader("Asha,34,Pune\nRavi,41,Kochi\nMeera,29,Indore\n".AsMemory());
int count = 0;
while (await reader.NextAsync() is ReadOnlyMemory<char> line)
    Console.WriteLine($"line {++count}: {line.Length} characters, \"{line}\"");
Console.WriteLine($"{reader.Remaining} characters left");

sealed class LineReader(ReadOnlyMemory<char> text)
{
    private ReadOnlyMemory<char> _rest = text; // a field of a class: allowed for Memory<T>, refused for Span<T>

    public int Remaining => _rest.Length;

    public async Task<ReadOnlyMemory<char>?> NextAsync()
    {
        await Task.Yield(); // stands in for waiting on the network
        if (_rest.IsEmpty) return null;
        int end = _rest.Span.IndexOf('\n'); // a span for the synchronous work, between two awaits
        ReadOnlyMemory<char> line = _rest[..end];
        _rest = _rest[(end + 1)..];
        return line;
    }
}

line 1: 12 characters, "Asha,34,Pune"
line 2: 13 characters, "Ravi,41,Kochi"
line 3: 15 characters, "Meera,29,Indore"
0 characters left

Each call awaited first, then took _rest.Span to find the next newline, and sliced the memory itself for the line it returned and the rest it kept. The three lines and the field all point into the one string the reader was given.

Microsoft’s usage guidelines turn the table into two rules for APIs: a synchronous method takes a Span<T>, because any caller that holds a Memory<T> can pass its .Span, and a method that only reads takes the read-only type. For parsing, int.Parse reads a ReadOnlySpan<char> directly. MemoryExtensions.Split finds the fields of a span without making strings. SearchValues prepares a set of characters once for fast searches. C# 14 converts arrays to spans in more places, so more span methods can be called on arrays directly. Code that keeps a Memory<T> must also respect how long it may use it, which the guidelines call a lease.

Parsing records with spans, measured to the byte Pro: opens with a Pro, Premium or Ultimate pass

What the compiler refuses, and what C# 14 converts for you Pro: opens with a Pro, Premium or Ultimate pass

Who may use a Memory buffer across async code, and until when Pro: opens with a Pro, Premium or Ultimate pass

Practise

Check yourself on views and slicing and on choosing between a span and Memory<T>. The session picks the next question from your earlier answers and explains each choice as soon as you make it:

Interview questions

Fresher · What is the difference between Span<T> and Memory<T>?

Both are views of a run of values that sit next to each other in memory, such as part of an array or a string, and neither copies what it views. Span<T> is a ref struct: it can live only on the stack, so it cannot be a field of a class, be captured by a lambda or be kept across an await, but it can also view stack memory from stackalloc, and it is the fastest to use. Memory<T> is an ordinary struct that can be stored anywhere, so it suits buffers that async code or an object keeps; to work on its values you take its Span property. A synchronous method should take a span, and code that stores a buffer or awaits should take a Memory<T>.

Key takeaways

• A span is a view: slicing an array or a string with a span copies nothing, and writing through a Span<T> writes the memory it views.
• Parsing through ReadOnlySpan<char> with the span overloads of int.Parse and the like reads text without making strings, 0 bytes a record against 150.1 with Split.
• Span<T> is a ref struct that stays on the stack; Memory<T> can be kept in fields and across await, and its Span property gives a span for the synchronous work.