Span<T> och Memory<T> är moderna .NET-typer för att arbeta effektivt med sammanhängande minne (arrayer, strängar, buffrar) — utan allokeringar eller kopiering. De möjliggör högpresterande kod genom att tillhandahålla en vy över befintligt minne istället för att skapa nya kopior, vilket minskar 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-slicing allokerar nya objekt och kopierar data. Span<T> tillhandahåller istället en vy (pekare + längd) över befintligt minne — slicing kostar ingenting, allokerar 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> låter dig slica och bearbeta arrayer/strängar/buffrar utan att allokera — avgörande för heta kodvägar (parsning, serialisering, bearbetning av stora 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> komplement Span<T> för scenarier där du behöver lagra vyn eller använda den i async-kod (där Span<T>s stack-only-natur inte fungerar).
Span<T> och Memory<T> är viktiga moderna .NET-funktioner för högpresterande, allokeringsfri kod, och att förstå dem är värdefull kunskap på högre nivå för prestanda-kritiska applikationer.
Deras kärnvärde är att möjliggöra effektivt arbete med sammanhängande minne (arrayer, strängar, buffrar) genom att tillhandahålla en vy över befintligt minne istället för att allokera nya kopior — vilket spelar roll eftersom allokeringar skapar GC-belastning, och i heta kodvägar (parsning, serialisering, bearbetning av stora datamängder, nätverksbuffrar) gör undvikande av allokeringar en betydande prestandaförbättring.
Operationer som normalt allokerar (Substring, array-slicing) kan göras allokeringsfritt med spans, vilket minskar minnesanvändning och GC-overhead.
Att förstå Span<T> (nollkopierings-slicing av arrayer/strängar/buffrar), dess stack-only-begränsning (det är en ref struct, så det kan inte vara ett klassfält eller användas i async-metoder — en viktig begränsning), och Memory<T> (komplementet som kan lagras och användas i async-kod) är viktigt för att skriva högpresterande C#.
Dessa typer används omfattande i moderna .NETs egen prestanda-kritiska kod och allt mer i bibliotek och applikationer där allokeringsfri, effektiv minneshantering spelar roll.
Även om de inte behövs för vardaglig affärslogik är det värdefullt för prestanda-känslig C#-utveckling (parsning, serialisering, högdataflödessystem) att förstå Span<T>/Memory<T> — vad de gör (allokeringsfritt minnesvyer), varför de hjälper (minskade allokeringar och GC-belastning), och deras begränsningar — det särskiljer utvecklare som kan skriva högeffektiv .NET-kod och är ett relevant ämne för prestanda-fokuserade senior-roller.