Span<T> e Memory<T> sono tipi moderni di .NET per lavorare con memoria contigua (array, stringhe, buffer) in modo efficiente — senza allocazioni o copie. Abilitano codice ad alte prestazioni fornendo una vista nella memoria esistente piuttosto che creare nuove copie, riducendo la pressione sul 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
Operazioni come Substring o lo slicing di array allocano nuovi oggetti e copiano i dati. Span<T> invece fornisce una vista (puntatore + lunghezza) nella memoria esistente — lo slicing non costa nulla, non alloca nulla.
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> ti permette di affettare ed elaborare array/stringhe/buffer senza allocare — cruciale per hot path (parsing, serializzazione, elaborazione di grandi dati).
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> complementa Span<T> per scenari in cui hai bisogno di memorizzare la vista o usarla in codice async (dove la natura stack-only di Span<T> non funziona).
Span<T> e Memory<T> sono importanti feature moderne di .NET per codice ad alte prestazioni, senza allocazioni, e comprenderli è una conoscenza di livello senior preziosa per applicazioni critiche per le prestazioni.
Il loro valore principale è abilitare un lavoro efficiente con memoria contigua (array, stringhe, buffer) fornendo una vista nella memoria esistente piuttosto che allocare nuove copie — cosa che importa perché le allocazioni creano pressione sul GC, e negli hot path (parsing, serializzazione, elaborazione di grandi dati, buffer di rete) evitare allocazioni migliora significativamente le prestazioni.
Operazioni che normalmente allocano (Substring, slicing di array) possono essere fatte senza allocazioni con span, riducendo l'uso di memoria e l'overhead del GC.
Comprendere Span<T> (slicing a zero-copy di array/stringhe/buffer), il suo vincolo stack-only (è un ref struct, quindi non può essere un campo di classe o usato in metodi async — un vincolo chiave), e Memory<T> (il complemento che può essere memorizzato e usato in codice async) è importante per scrivere C# ad alte prestazioni.
Questi tipi sono usati estensivamente nel codice stesso critico per le prestazioni di .NET moderno e sempre più in librerie e applicazioni dove la gestione efficiente della memoria senza allocazioni importa.
Sebbene non necessari per la logica di business ordinaria, comprendere Span<T>/Memory<T> — cosa fanno (viste di memoria senza allocazioni), perché aiutano (allocazioni ridotte e pressione sul GC), e i loro vincoli — è prezioso per lo sviluppo C# sensibile alle prestazioni (parsing, serializzazione, sistemi ad alto throughput), distinguendo sviluppatori che possono scrivere codice .NET altamente efficiente, ed è un argomento rilevante per ruoli senior orientati alle prestazioni.