Span<T> și Memory<T> sunt tipuri moderne din .NET pentru a lucra cu memorie contiguă (arrays, stringuri, buffere) eficient — fără alocări sau copieri. Ele permit scrierea de cod cu performanță ridicată prin oferirea unei vederi asupra memoriei existente în loc de a crea copii noi, reducând presiunea pe 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
Operații cum ar fi Substring sau slicing-ul array-urilor alocă obiecte noi și copiază date. Span<T> oferă în schimb o vedere (pointer + lungime) asupra memoriei existente — slicing-ul nu costă nimic, nu alocă nimic.
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> te permite să faci slice și să procesezi arrays/stringuri/buffere fără alocări — crucial pentru căile fierbinți (parsing, serializare, procesare date mari).
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> completează Span<T> pentru scenarii în care trebuie să stochezi vederea sau să o folosești în cod async (unde natura stack-only a Span<T> nu funcționează).
Span<T> și Memory<T> sunt caracteristici moderne importante din .NET pentru codul cu performanță ridicată, fără alocări, și înțelegerea lor este cunoștințe valoroase la nivel senior pentru aplicații critice din punct de vedere al performanței.
Valoarea lor de bază este permiterea lucrului eficient cu memorie contiguă (arrays, stringuri, buffere) prin oferirea unei vederi asupra memoriei existente în loc de a aloca copii noi — ceea ce conteaza pentru că alocările creează presiune pe GC, iar în căile fierbinți (parsing, serializare, procesare date mari, buffere de rețea) evitarea alocărilor îmbunătățește semnificativ performanța.
Operații care normal alocă (Substring, slicing-ul array-urilor) pot fi făcute fără alocări cu span-uri, reducând utilizarea memoriei și overhead-ul GC.
Înțelegerea Span<T> (slicing fără copiere al arrays/stringuri/buffere), a constrângerii sale stack-only (este un ref struct, deci nu poate fi un câmp de clasă sau folosit în metode async — o limitare cheie) și a Memory<T> (complementul care poate fi stocat și folosit în cod async) este importantă pentru scrierea codului C# cu performanță ridicată.
Aceste tipuri sunt folosite pe scară largă în codul propriu performanță-critic al .NET-ului modern și din ce în ce mai mult în biblioteci și aplicații în care manipularea eficientă a memoriei, fără alocări, conteaza.
Deși nu sunt necesare pentru logica obișnuită de afaceri, înțelegerea Span<T>/Memory<T> — ce fac ele (vederi de memorie fără alocări), de ce ajută (alocări reduse și presiune pe GC redusă) și constrângerile lor — este valoroasă pentru dezvoltarea C# sensibilă la performanță (parsing, serializare, sisteme cu throughput ridicat), distinge dezvoltatorii care pot scrie cod .NET extrem de eficient și este un subiect relevant pentru roluri senior orientate pe performanță.