Span<T> and allocation-free code

Copies everywhere

Classic string and array code copies a lot:

string line = "2024-10-06,Ada,42.50";
string[] parts = line.Split(',');          // allocates an array + 3 new strings
string year = parts[0].Substring(0, 4);    // another new string
int y = int.Parse(year);

For one line that's fine. For a server parsing millions of lines or requests, those temporary strings become a mountain of garbage for the GC. Span<T> lets you work with a slice of existing memory without copying it.

What is a span?

A Span<T> is a lightweight view over a contiguous region of memory: just a reference to the start plus a length. It can point into an array, a string, stack memory or native memory — and slicing a span creates another view, not a copy.

int[] numbers = { 1, 2, 3, 4, 5, 6 };
Span<int> middle = numbers.AsSpan(2, 3);   // views 3, 4, 5 — no copy
 
middle[0] = 99;                            // writes through to the array!
Console.WriteLine(numbers[2]);             // 99

Strings are immutable, so they give you a ReadOnlySpan<char>:

ReadOnlySpan<char> text = "2024-10-06,Ada,42.50";
ReadOnlySpan<char> date = text[..10];      // "2024-10-06" — a view, no new string
int year = int.Parse(date[..4]);           // parse straight from the span

Most parsing and formatting APIs accept spans: int.Parse, double.TryParse, Guid.Parse, DateTime.Parse, IndexOf, StartsWith, Trim, SequenceEqual…

Parsing without allocating

decimal SumPrices(ReadOnlySpan<char> csv)
{
    decimal total = 0;
    while (!csv.IsEmpty)
    {
        int comma = csv.IndexOf(',');
        var field = comma >= 0 ? csv[..comma] : csv;
        total += decimal.Parse(field, CultureInfo.InvariantCulture);
        csv = comma >= 0 ? csv[(comma + 1)..] : ReadOnlySpan<char>.Empty;
    }
    return total;
}

No arrays, no substrings — zero allocations however long the input.

Stack buffers with stackalloc

For a small temporary buffer, allocate it on the stack — free for the GC:

Span<char> buffer = stackalloc char[32];
bool ok = DateTime.Now.TryFormat(buffer, out int written, "yyyy-MM-dd");
Console.WriteLine(buffer[..written].ToString());

The rules: spans live on the stack

Span<T> is a ref struct: it may point to stack memory, so the compiler ensures it never ends up on the heap. A span can't:

• be a field of a class (or a normal struct),
• be boxed or used as a generic type argument,
• be captured by a lambda, or live across an await or yield return.

When you need a heap-friendly version (in a class field or an async method), use Memory<T> / ReadOnlyMemory<T> and call .Span where you do the work.

Reusing buffers: ArrayPool

When you need real arrays repeatedly (I/O buffers, for example), rent them from a pool instead of allocating:

byte[] buffer = ArrayPool<byte>.Shared.Rent(64 * 1024);
try
{
    int read = await stream.ReadAsync(buffer);
    // ... use buffer.AsSpan(0, read) ...
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);
}

Try it

Key takeaways

• Span<T> / ReadOnlySpan<T> are views over existing memory: slicing doesn't copy.
• Parse directly from spans to avoid temporary strings and arrays.
• stackalloc gives GC-free temporary buffers; ArrayPool lets you reuse large arrays.
• Spans are ref structs: no fields in classes, no lambdas, no await — use Memory<T> there.