Span<T> og Memory<T> er moderne .NET-typer for effektiv arbeid med sammenhengende minne (arrays, strenger, buffere) — uten allokeringer eller kopiering. De muliggjør høytytende kode ved å gi en visning av eksisterende minne i stedet for å lage nye kopier, noe som reduserer GC-trykket.
// ❌ 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
Operasjoner som Substring eller array-slicing allokerer nye objekter og kopierer data. Span<T> gir i stedet en visning (peker + lengde) av eksisterende minne — slicing 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> lar deg slice og behandle arrays/strenger/buffere uten å allokere — kritisk for varme stier (parsing, serialisering, behandling av store 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> komplementerer Span<T> for scenarier der du trenger å lagre visuellen eller bruke den i asynk kode (der Span<T>s stack-bare natur ikke fungerer).
Span<T> og Memory<T> er viktige moderne .NET-funksjoner for høytytende, allokeringsfri kode, og forståelsen av dem er verdifull kunnskap på seniornivå for ytelseskritiske applikasjoner.
Kjernenverdien deres er å muliggjøre effektivt arbeid med sammenhengende minne (arrays, strenger, buffere) ved å gi en visning av eksisterende minne i stedet for å allokere nye kopier — noe som er viktig fordi allokeringer skaper GC-trykk, og i varme stier (parsing, serialisering, behandling av store data, nettverksbuffere) unngåelse av allokeringer forbedrer ytelsen betydelig.
Operasjoner som normalt allokerer (Substring, array-slicing) kan gjøres allokeringsfrit med spans, noe som reduserer minneforbruk og GC-overhead.
Forståelse av Span<T> (null-kopi slicing av arrays/strenger/buffere), dens stack-bare begrensning (det er en ref struct, så den kan ikke være et klassefeld eller brukes i asynkrone metoder — en nøkkelbegrensning), og Memory<T> (komplementet som kan lagres og brukes i asynk kode) er viktig for å skrive høytytende C#.
Disse typene brukes omfattende i moderne .NETs egen ytelseskritiske kode og i økende grad i biblioteker og applikasjoner der allokeringsfri, effektiv minnehåndtering spiller en rolle.
Hvist ikke nødvendig for daglig forretningslogikk, er forståelse av Span<T>/Memory<T> — hva de gjør (allokeringsfrie minnevisninger), hvorfor de hjelper (reduserte allokeringer og GC-trykk), og deres begrensninger — verdifull for ytelsessensitiv C#-utvikling (parsing, serialisering, høytgjennomstrømningssystemer), som skiller utviklere som kan skrive svært effektiv .NET-kode, og er et relevant emne for ytelsessentrerte seniorroller.