Span<T> en Memory<T> zijn moderne .NET-typen voor het efficiënt werken met aaneengesloten geheugen (arrays, strings, buffers) — zonder toewijzingen of kopiëren. Ze maken hoogperformante code mogelijk door een weergave van bestaand geheugen te bieden in plaats van nieuwe kopieën te maken, waardoor GC-druk wordt verminderd.
// ❌ 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
Bewerkingen zoals Substring of array slicing wijzen nieuwe objecten toe en kopiëren gegevens. Span<T> biedt daarentegen een weergave (pointer + lengte) van bestaand geheugen — slicing kost niets, wijst niets toe.
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> laat je arrays/strings/buffers slicen en verwerken zonder toewijzingen — cruciaal voor hot paths (parsing, serialisatie, verwerking van grote gegevens).
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> completeert Span<T> voor scenario's waar je de weergave moet opslaan of gebruiken in async-code (waar Span<T>'s stack-only aard niet werkt).
Span<T> en Memory<T> zijn belangrijke moderne .NET-functies voor hoogperformante, toewijzingsvrije code, en het begrijpen ervan is waardevol senior-level kennis voor prestatiekritieke toepassingen.
Hun kernwaarde is het mogelijk maken van efficiënt werk met aaneengesloten geheugen (arrays, strings, buffers) door een weergave van bestaand geheugen te bieden in plaats van nieuwe kopieën toe te wijzen — wat belangrijk is omdat toewijzingen GC-druk creëren, en in hot paths (parsing, serialisatie, verwerking van grote gegevens, netwerkbuffers) het vermijden van toewijzingen de prestaties aanzienlijk verbetert.
Bewerkingen die normaal toewijzen (Substring, array slicing) kunnen toewijzingvrij worden gedaan met spans, wat geheugengebruik en GC-overhead vermindert.
Het begrijpen van Span<T> (zero-copy slicing van arrays/strings/buffers), zijn stack-only beperking (het is een ref struct, dus het kan geen klasveld zijn of in async-methoden worden gebruikt — een belangrijke beperking), en Memory<T> (het complement dat kan worden opgeslagen en in async-code kan worden gebruikt) is belangrijk voor het schrijven van hoogperformante C#.
Deze typen worden uitgebreid gebruikt in de eigen prestatiekritieke code van modern .NET en steeds meer in bibliotheken en toepassingen waar toewijzingsvrije, efficiënte geheugenverwerking belangrijk is.
Hoewel niet nodig voor alledaagse bedrijfslogica, is het begrijpen van Span<T>/Memory<T> — wat ze doen (toewijzingsvrije geheugenuitzichten), waarom ze helpen (verminderde toewijzingen en GC-druk), en hun beperkingen — waardevol voor prestatiesgevoelige C#-ontwikkeling (parsing, serialisatie, hoge-doorvoersystemen), onderscheidt ontwikkelaars die zeer efficiënte .NET-code kunnen schrijven, en is een relevant onderwerp voor prestatiesgefocuste senior-rollen.