Span<T> og Memory<T> er moderne .NET-typer til arbejde med sammenhængende hukommelse (arrays, strenge, buffere) effektivt — uden allokeringer eller kopiering. De muliggør højtydelseskode ved at give en visning ind i eksisterende hukommelse i stedet for at oprette nye kopier, hvilket reducerer GC-belastningen.
// ❌ 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
Operationer som Substring eller array-opdeling allokerer nye objekter og kopierer data. Span<T> giver i stedet en visning (pointer + længde) ind i eksisterende hukommelse — opdeling koster ingenting, allokerer ingenting.
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> lader dig opdele og behandle arrays/strenge/buffere uden at allokere — afgørende for hot paths (parsing, serialisering, behandling af store datamængder).
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> komplementerer Span<T> for scenarioer, hvor du skal lagre visningen eller bruge den i asynk kode (hvor Span<T>'s stack-only natur ikke fungerer).
Span<T> og Memory<T> er vigtige moderne .NET-funktioner til højtydelse, allokeringsfri kode, og forståelse af dem er værdifuld senior-niveau viden til performance-kritiske applikationer.
Deres kerneverdi er at muliggøre effektivt arbejde med sammenhængende hukommelse (arrays, strenge, buffere) ved at give en visning ind i eksisterende hukommelse i stedet for at allokere nye kopier — hvilket betyder noget, fordi allokeringer skaber GC-belastning, og i hot paths (parsing, serialisering, behandling af store datamængder, netværksbuffere) formindsker undgåelse af allokeringer ydeevnen betydeligt.
Operationer, der normalt allokerer (Substring, array-opdeling), kan gøres allokeringsfri med spans, hvilket reducerer hukommelsesforbrug og GC-overhead.
Forståelse af Span<T> (kopiringsfri opdeling af arrays/strenge/buffere), dets stack-only begrænsning (det er en ref struct, så det kan ikke være et klassefelt eller bruges i asynke metoder — en vigtig begrænsning) og Memory<T> (komplementet, der kan lagres og bruges i asynk kode) er vigtig for at skrive højtydende C#.
Disse typer bruges omfattende i modernes .NET's egen performance-kritiske kode og i stigende grad i biblioteker og applikationer, hvor allokeringsfri, effektiv hukommelsesbåndling betyder noget.
Skønt ikke nødvendig for daglig forretningslogik, er forståelse af Span<T>/Memory<T> — hvad de gør (allokeringsfri hukommelsesvisninger), hvorfor de hjælper (reducerede allokeringer og GC-belastning) og deres begrænsninger — værdifuld for performance-sensitive C#-udvikling (parsing, serialisering, højtdatagennemsætningssystemer), der adskiller udviklere, der kan skrive meget effektiv .NET-kode, og er et relevant emne for performance-fokuserede senior-roller.