Span<T> y Memory<T> son tipos modernos de .NET para trabajar con memoria contigua (arrays, strings, buffers) de manera eficiente — sin asignaciones ni copias. Permiten código de alto rendimiento al proporcionar una vista en la memoria existente en lugar de crear nuevas copias, reduciendo la presión del 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
Operaciones como Substring o slicing de arrays asignan nuevos objetos y copian datos. Span<T> en cambio proporciona una vista (puntero + longitud) en la memoria existente — el slicing no cuesta nada, no asigna 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> te permite hacer slicing y procesar arrays/strings/buffers sin asignar — crucial para rutas críticas (parsing, serialización, procesamiento de datos 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 escenarios donde necesitas almacenar la vista o usarla en código async (donde la naturaleza solo-stack de Span<T> no funciona).
Span<T> y Memory<T> son características modernas importantes de .NET para código de alto rendimiento, sin asignaciones, y comprenderlas es conocimiento valioso de nivel senior para aplicaciones críticas en rendimiento.
Su valor central es permitir trabajo eficiente con memoria contigua (arrays, strings, buffers) proporcionando una vista en la memoria existente en lugar de asignar nuevas copias — lo cual importa porque las asignaciones crean presión de GC, y en rutas críticas (parsing, serialización, procesamiento de datos grandes, buffers de red) evitar asignaciones mejora significativamente el rendimiento.
Operaciones que normalmente asignan (Substring, slicing de arrays) pueden hacerse sin asignaciones con spans, reduciendo el uso de memoria y la sobrecarga del GC.
Comprender Span<T> (slicing sin copias de arrays/strings/buffers), su restricción solo-stack (es un ref struct, por lo que no puede ser un campo de clase ni usarse en métodos async — una limitación clave), y Memory<T> (el complemento que sí puede almacenarse y usarse en código async) es importante para escribir C# de alto rendimiento.
Estos tipos se usan extensamente en el propio código de rendimiento crítico de .NET moderno e incrementalmente en librerías y aplicaciones donde el manejo de memoria eficiente y sin asignaciones importa.
Aunque no son necesarios para la lógica empresarial cotidiana, comprender Span<T>/Memory<T> — qué hacen (vistas de memoria sin asignaciones), por qué ayudan (asignaciones reducidas y presión de GC menor), y sus restricciones — es valioso para desarrollo C# sensible al rendimiento (parsing, serialización, sistemas de alto rendimiento), distingue a desarrolladores que pueden escribir código .NET altamente eficiente, y es un tema relevante para roles senior enfocados en rendimiento.