📝 Lesson 4.2: Span and Memory

The Cost of Copying

Slicing data traditionally means copying it. Every Substring, every array[a..b] copy, allocates a new object on the heap — adding GC pressure (Lesson 4.1). In a hot loop parsing millions of records, those copies dominate.

string csv = "name,age,city";

// Each Split entry and each Substring is a NEW heap-allocated string
string[] parts = csv.Split(',');       // allocates an array + 3 strings
string first = csv.Substring(0, 4);    // allocates another string

Span as a Window

A Span<T> holds a reference to the start of some memory and a length. It doesn't copy the data — it points into it. Writing through a span modifies the underlying storage:

int[] numbers = { 10, 20, 30, 40, 50 };

Span<int> span = numbers;        // a view over the whole array (no copy)
span[0] = 99;                    // writes through to the array
Console.WriteLine(numbers[0]);   // 99 — same underlying memory

Multiple spans can view the same array — or different parts of it — all sharing one allocation.

Slicing Without Allocating

The whole point: Slice (or the range operator [a..b]) produces a sub-view with no allocation — just a new start and length pointing into the same memory:

int[] numbers = { 10, 20, 30, 40, 50 };
Span<int> all = numbers;

Span<int> middle = all.Slice(1, 3);   // { 20, 30, 40 } — no copy
Span<int> tail = all[2..];            // { 30, 40, 50 } — range syntax, no copy

middle[0] = 999;                       // writes into the original array
Console.WriteLine(numbers[1]);        // 999

Contrast a summing routine that takes a Span<int> — it works on any array or slice with zero copying:

static long Sum(ReadOnlySpan<int> values)   // accepts arrays AND slices, no alloc
{
    long total = 0;
    foreach (int v in values) total += v;
    return total;
}

int[] data = Enumerable.Range(1, 100).ToArray();
Console.WriteLine(Sum(data));            // whole array
Console.WriteLine(Sum(data.AsSpan(0, 10))); // first 10 — no new array

Spans over Strings

Strings are immutable, but you can create a ReadOnlySpan<char> over one with AsSpan() — enabling substring-like operations without allocating new strings:

string date = "2026-08-07";

ReadOnlySpan<char> span = date.AsSpan();

ReadOnlySpan<char> yearSpan  = span.Slice(0, 4);   // "2026" — no new string
ReadOnlySpan<char> monthSpan = span.Slice(5, 2);   // "08"
ReadOnlySpan<char> daySpan   = span[8..];          // "07"

// Modern parsing accepts spans directly — parse without ever allocating a substring
int year  = int.Parse(yearSpan);
int month = int.Parse(monthSpan);
int day   = int.Parse(daySpan);

Console.WriteLine($"{year}/{month}/{day}");   // 2026/8/7

stackalloc and Buffers

For small, short-lived buffers, stackalloc allocates on the stack instead of the heap — no GC involvement at all. Combined with Span<T>, it gives you a scratch buffer that's freed instantly when the method returns:

Span<int> buffer = stackalloc int[16];   // 16 ints on the stack — zero heap allocation

for (int i = 0; i < buffer.Length; i++)
{
    buffer[i] = i * i;
}
Console.WriteLine(buffer[4]);   // 16

The ref struct Rules

Span<T> is a ref struct (Lesson 4.1) — a value type that the compiler guarantees lives only on the stack. This guarantee is what makes it safe to point at stack memory, but it comes with restrictions:

Memory<T> for Async

Memory<T> is the heap-friendly cousin of Span<T>. It represents the same idea — a view over contiguous memory without copying — but as a regular struct (not a ref struct), so it can be stored in fields and used across await.

async Task ProcessAsync(Memory<byte> buffer)   // Memory is allowed across await
{
    int bytesRead = await ReadIntoAsync(buffer);

    // Get a Span only when you need to touch the elements (synchronously)
    Span<byte> span = buffer.Span;
    Process(span.Slice(0, bytesRead));
}

Exercise & Quiz

Console.WriteLine(SumCsv("10,20,30,40,50".AsSpan()));   // 150

static int SumCsv(ReadOnlySpan<char> line)
{
    int total = 0;
    // TODO: loop using IndexOf(',') and int.Parse on slices; handle the last field
    return total;
}

Console.WriteLine(SumCsv("10,20,30,40,50".AsSpan()));   // 150

// Bonus
Span<int> squares = stackalloc int[5];
for (int i = 0; i < squares.Length; i++) squares[i] = (i + 1) * (i + 1);
int sqSum = 0;
foreach (int s in squares) sqSum += s;
Console.WriteLine(sqSum);   // 55

static int SumCsv(ReadOnlySpan<char> line)
{
    int total = 0;
    int comma;
    while ((comma = line.IndexOf(',')) >= 0)
    {
        total += int.Parse(line.Slice(0, comma));   // parse field, no substring
        line = line.Slice(comma + 1);               // advance the view
    }
    total += int.Parse(line);                       // last field
    return total;
}

Summary

📚 Additional Resources

• Memory and spans — Microsoft Docs
• Span<T> — API reference
• Memory<T> usage guidelines

🚀 What's Next?

You can process data without copying it. To close the module, we measure and reduce allocations directly. In Lesson 4.3: Allocations, GC, and Benchmarking, you'll learn how the garbage collector works and prove your optimizations with BenchmarkDotNet.