Span<T> e Memory<T> são tipos modernos do .NET para trabalhar com memória contígua (arrays, strings, buffers) eficientemente — sem alocações ou cópias. Eles permitem código de alto desempenho ao fornecer uma visualização da memória existente em vez de criar novas cópias, reduzindo a pressão no 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ções como Substring ou slicing de array alocam novos objetos e copiam dados. Span<T> em vez disso fornece uma visualização (ponteiro + comprimento) da memória existente — slicing não custa nada, não aloca nada.
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> permite fatiar e processar arrays/strings/buffers sem alocar — crucial para caminhos críticos (parsing, serialização, processamento de dados grandes).
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> para cenários onde você precisa armazenar a visualização ou usá-la em código async (onde a natureza stack-only de Span<T> não funciona).
Span<T> e Memory<T> são recursos modernos importantes do .NET para código de alto desempenho e sem alocações, e entendê-los é conhecimento valioso de nível sênior para aplicações críticas em desempenho.
Seu valor central é permitir trabalho eficiente com memória contígua (arrays, strings, buffers) fornecendo uma visualização da memória existente em vez de alocar novas cópias — isso importa porque alocações criam pressão no GC, e em caminhos críticos (parsing, serialização, processamento de dados grandes, buffers de rede) evitar alocações melhora significativamente o desempenho.
Operações que normalmente alocam (Substring, slicing de array) podem ser feitas sem alocação com spans, reduzindo uso de memória e overhead do GC.
Entender Span<T> (slicing sem cópia de arrays/strings/buffers), sua restrição stack-only (é um ref struct, então não pode ser um campo de classe ou usado em métodos async — uma limitação chave), e Memory<T> (o complemento que pode ser armazenado e usado em código async) é importante para escrever C# de alto desempenho.
Esses tipos são usados extensivamente no próprio código crítico em desempenho do .NET moderno e cada vez mais em bibliotecas e aplicações onde manipulação de memória eficiente e sem alocação importa.
Embora não seja necessário para lógica comercial cotidiana, entender Span<T>/Memory<T> — o que eles fazem (visualizações de memória sem alocação), por que ajudam (alocações reduzidas e menor pressão no GC), e suas restrições — é valioso para desenvolvimento C# sensível a desempenho (parsing, serialização, sistemas de alta throughput), distinguindo desenvolvedores que podem escrever código .NET altamente eficiente, e é um tópico relevante para funções sênior focadas em desempenho.