Span<T> i Memory<T> to nowoczesne typy .NET do pracy z ciągłą pamięcią (tablice, stringi, bufory) w wydajny sposób — bez alokacji lub kopiowania. Umożliwiają kod o wysokiej wydajności, dostarczając widok istniejącej pamięci zamiast tworzenia nowych kopii, zmniejszając presję na GC.
// ❌ 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
Operacje takie jak Substring lub slicowanie tablic alokują nowe obiekty i kopiują dane. Span<T> zamiast tego dostarcza widok (wskaźnik + długość) istniejącej pamięci — slicowanie nic nie kosztuje, nic nie alokuje.
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> pozwala na slicowanie i przetwarzanie tablic/stringów/buforów bez alokacji — kluczowe dla gorących ścieżek (parsing, serializacja, przetwarzanie dużych danych).
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> uzupełnia Span<T> dla scenariuszy, gdzie trzeba przechowywać widok lub używać go w kodzie asynchronicznym (gdzie charakter samodzielnie stosu Span<T> nie działa).
Span<T> i Memory<T> to ważne nowoczesne cechy .NET dla wysokowydajnego, wolnego od alokacji kodu, a ich zrozumienie to cenna wiedza na poziomie seniora dla aplikacji krytycznych wydajnościowo.
Ich podstawowa wartość to umożliwienie efektywnej pracy z ciągłą pamięcią (tablice, stringi, bufory) poprzez dostarczenie widoku istniejącej pamięci zamiast alokacji nowych kopii — co jest ważne, ponieważ alokacje tworzą presję na GC, a w gorących ścieżkach (parsing, serializacja, przetwarzanie dużych danych, bufory sieciowe) unikanie alokacji znacząco poprawia wydajność.
Operacje, które zwykle alokują (Substring, slicowanie tablic), mogą być wykonywane bez alokacji za pomocą spanów, zmniejszając zużycie pamięci i obciążenie GC.
Zrozumienie Span<T> (slicowanie bez kopiowania tablic/stringów/buforów), jego ograniczenia dotyczące stosu (to jest ref struct, więc nie może być polem klasy lub używany w metodach asynchronicznych — kluczowe ograniczenie), i Memory<T> (uzupełnienie, które może być przechowywane i używane w kodzie asynchronicznym) jest ważne do pisania wysoko wydajnego C#.
Te typy są szeroko stosowane we własnym wydajnościowo-krytycznym kodzie nowoczesnego .NET i coraz częściej w bibliotekach i aplikacjach, gdzie alokacja bez alokacji, efektywna obsługa pamięci ma znaczenie.
Chociaż nie są potrzebne do zwykłej logiki biznesowej, zrozumienie Span<T>/Memory<T> — co robią (widoki pamięci bez alokacji), dlaczego pomagają (zmniejszone alokacje i presja na GC), i ich ograniczenia — jest cenne dla wydajnościowo-wrażliwego programowania w C# (parsing, serializacja, systemy o wysokiej przepustowości), wyróżnia programistów potrafiących pisać wysoce wydajny kod .NET, i jest istotnym tematem dla wydajnościowo-skoncentrowanych ról seniora.