Span<T> et Memory<T> sont des types .NET modernes pour travailler avec de la mémoire contiguë (tableaux, chaînes, tampons) efficacement — sans allocations ni copie. Ils permettent du code hautement performant en fournissant une vue sur la mémoire existante plutôt que de créer de nouvelles copies, réduisant la pression sur le garbage collector.
// ❌ 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
Des opérations comme Substring ou le découpage de tableaux allouent de nouveaux objets et copient les données. Span<T> fournit plutôt une vue (pointeur + longueur) sur la mémoire existante — le découpage ne coûte rien, n'alloue rien.
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> vous permet de découper et traiter des tableaux/chaînes/tampons sans allouer — crucial pour les chemins chauds (parsing, sérialisation, traitement de grandes données).
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> complète Span<T> pour les scénarios où vous avez besoin de stocker la vue ou de l'utiliser dans du code asynchrone (où la nature limitée à la pile de Span<T> ne fonctionne pas).
Span<T> et Memory<T> sont des fonctionnalités .NET modernes importantes pour du code hautement performant et sans allocations, et les comprendre est une connaissance précieuse de haut niveau pour les applications critiques en termes de performance.
Leur valeur principale est de permettre un travail efficace avec la mémoire contiguë (tableaux, chaînes, tampons) en fournissant une vue sur la mémoire existante plutôt que d'allouer de nouvelles copies — ce qui importe car les allocations créent de la pression sur le GC, et sur les chemins chauds (parsing, sérialisation, traitement de grandes données, tampons réseau) éviter les allocations améliore significativement les performances.
Les opérations qui allouent normalement (Substring, découpage de tableaux) peuvent être faites sans allocation avec les spans, réduisant l'utilisation mémoire et la surcharge du GC.
Comprendre Span<T> (découpage sans copie de tableaux/chaînes/tampons), sa contrainte limitée à la pile (c'est un ref struct, donc il ne peut pas être un champ de classe ou utilisé dans des méthodes asynchrones — une limitation clé), et Memory<T> (le complément qui peut être stocké et utilisé dans du code asynchrone) est important pour écrire du C# hautement performant.
Ces types sont utilisés extensivement dans le code critique en termes de performance du .NET lui-même et de plus en plus dans les bibliothèques et applications où la gestion mémoire efficace et sans allocation importe.
Bien que non nécessaire pour la logique métier quotidienne, comprendre Span<T>/Memory<T> — ce qu'ils font (vues mémoire sans allocation), pourquoi ils aident (allocations réduites et moins de pression sur le GC), et leurs contraintes — est précieux pour le développement C# sensible aux performances (parsing, sérialisation, systèmes haut débit), distingue les développeurs qui peuvent écrire du code .NET hautement efficace, et est un sujet pertinent pour les rôles seniors axés sur la performance.