Span<T> und Memory<T> sind moderne .NET-Typen für die effiziente Arbeit mit zusammenhängendem Speicher (Arrays, Strings, Buffer) — ohne Zuweisungen oder Kopieren. Sie ermöglichen High-Performance-Code, indem sie eine Ansicht in vorhandenen Speicher bieten, anstatt neue Kopien zu erstellen, was den GC-Druck reduziert.
// ❌ 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
Operationen wie Substring oder Array-Slicing weisen neue Objekte zu und kopieren Daten. Span<T> bietet stattdessen eine Ansicht (Zeiger + Länge) in vorhandenen Speicher — Slicing kostet nichts, weist nichts zu.
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> ermöglicht es Ihnen, Arrays/Strings/Buffer zu slicen und zu verarbeiten, ohne zuzuweisen — entscheidend für Hot Paths (Parsing, Serialisierung, Verarbeitung großer Datenmengen).
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> ergänzt Span<T> für Szenarien, in denen Sie die Ansicht speichern oder sie in asynchronem Code verwenden müssen (wobei Span<T>s Stack-Only-Natur nicht funktioniert).
Span<T> und Memory<T> sind wichtige moderne .NET-Features für High-Performance-, allokationsfreien Code, und deren Verständnis ist wertvoll, Senior-Level-Wissen für leistungskritische Anwendungen.
Ihr Kernwert liegt darin, effiziente Arbeit mit zusammenhängendem Speicher (Arrays, Strings, Buffer) zu ermöglichen, indem eine Ansicht in vorhandenen Speicher bereitgestellt wird, anstatt neue Kopien zuzuweisen — was wichtig ist, weil Zuweisungen GC-Druck erzeugen, und in Hot Paths (Parsing, Serialisierung, Verarbeitung großer Datenmengen, Netzwerk-Buffer) das Vermeiden von Zuweisungen die Leistung erheblich verbessert.
Operationen, die normalerweise zuweisen (Substring, Array-Slicing), können mit Spans allokationsfrei durchgeführt werden, was die Speichernutzung und GC-Overhead reduziert.
Das Verständnis von Span<T> (Zero-Copy-Slicing von Arrays/Strings/Buffern), seiner Stack-Only-Einschränkung (es ist ein ref struct, daher kann es kein Klassenfeld sein oder in asynchronen Methoden verwendet werden — eine Schlüsselbeschränkung) und Memory<T> (das Komplement, das gespeichert und in asynchronem Code verwendet werden kann) ist wichtig für das Schreiben von hochperformanten C#.
Diese Typen werden umfangreich im leistungskritischen Code von .NET selbst und zunehmend in Bibliotheken und Anwendungen verwendet, wo allokationsfreie, effiziente Speicherbehandlung wichtig ist.
Während für alltägliche Geschäftslogik nicht erforderlich, ist das Verständnis von Span<T>/Memory<T> — was sie tun (allokationsfreie Speicheransichten), warum sie helfen (reduzierte Zuweisungen und GC-Druck) und ihre Einschränkungen — wertvoll für leistungsempfindliche C#-Entwicklung (Parsing, Serialisierung, High-Throughput-Systeme), unterscheidet Entwickler, die hocheffizienten .NET-Code schreiben können, und ist ein relevantes Thema für leistungsorientierte Senior-Rollen.