Span<T> and Memory<T> are modern .NET types for working with contiguous memory (arrays, strings, buffers) efficiently — without allocations or copying. They enable high-performance code by providing a view into existing memory rather than creating new copies, reducing GC pressure.
// ❌ Substring allocates a NEW string (copies the data) — GC pressure in hot paths
string text = "Hello, World";
string sub = text.Substring(7); // allocates a new "World" string
// ✅ Span — a VIEW into the existing memory, NO allocation, NO copy
ReadOnlySpan<char> span = text.AsSpan(7); // "World" — points into the original
Operations like Substring or array slicing allocate new objects and copy data. Span<T> instead provides a view (pointer + length) into existing memory — slicing costs nothing, allocates nothing.
int[] numbers = { 1, 2, 3, 4, 5 };
Span<int> slice = numbers.AsSpan(1, 3); // {2, 3, 4} — a VIEW, no copy
slice[0] = 99; // modifies the ORIGINAL array (it's a view)
// parse without allocating substrings
ReadOnlySpan<char> input = "123,456".AsSpan();
int first = int.Parse(input.Slice(0, 3)); // parse a slice, no substring allocation
Span<T> lets you slice and process arrays/strings/buffers without allocating — crucial for hot paths (parsing, serialization, processing large data).
Span<T> is a ref struct — it can ONLY live on the stack (not on the heap, not in
async methods, not as a class field). This guarantees safety but limits where it's used.
// Memory<T> is like Span<T> but CAN be a field / used across await (heap-storable)
async Task ProcessAsync(Memory<byte> buffer) // works in async (Span<T> can't)
{
await stream.ReadAsync(buffer);
Span<byte> span = buffer.Span; // get a Span from it when you need to process
}
Memory<T> complements Span<T> for scenarios where you need to store the view or use it in async code (where Span<T>'s stack-only nature doesn't work).
Span<T> and Memory<T> are important modern .NET features for high-performance, allocation-free code, and understanding them is valuable senior-level knowledge for performance-critical applications.
Their core value is enabling efficient work with contiguous memory (arrays, strings, buffers) by providing a view into existing memory rather than allocating new copies — which matters because allocations create GC pressure, and in hot paths (parsing, serialization, processing large data, network buffers) avoiding allocations significantly improves performance.
Operations that normally allocate (Substring, array slicing) can be done allocation-free with spans, reducing memory usage and GC overhead.
Understanding Span<T> (zero-copy slicing of arrays/strings/buffers), its stack-only constraint (it's a ref struct, so it can't be a class field or used in async methods — a key limitation), and Memory<T> (the complement that can be stored and used in async code) is important for writing high-performance C#.
These types are used extensively in modern .NET's own performance-critical code and increasingly in libraries and applications where allocation-free, efficient memory handling matters.
While not needed for everyday business logic, understanding Span<T>/Memory<T> — what they do (allocation-free memory views), why they help (reduced allocations and GC pressure), and their constraints — is valuable for performance-sensitive C# development (parsing, serialization, high-throughput systems), distinguishing developers who can write highly efficient .NET code, and is a relevant topic for performance-focused senior roles.