C# 7.2 : à la découverte des deux nouvelles fonctionnalités que sont Span<T> et Memory<T>

Un billet de François DORIN

Le 16 avril 2018, par François DORIN

0PARTAGES

Dans le billet du jour, nous allons partir à la découverte de nouvelles fonctionnalités introduites avec C# 7.2: Span et Memory.

L'objectif de ces deux nouvelles structures est de faciliter la manipulation de données, par exemple sous forme de tableau, et ceci de manière performante. Mais cela ne se limite pas aux tableaux ! Il peut s'agir d'un buffer, d'une string, de mémoire non managée, etc... Il s'agit donc d'une abstraction très intéressante pour la manipulation des données. Le seul prérequis : que les données soient contiguës en mémoire.

Span
L'intérêt majeur de Span est de permettre de manipuler un tableau ou un sous-ensemble de tableau de manière performante, car:

la structure est allouée sur la pile (donc allocation et déallocation très rapide);
aucune copie du tableau initiale n'est réalisée.

Prenons ce petit exemple:
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

Span span = array;
Span subSpan = span.Slice(4, 3);

Dans un premier temps, on instancie un tableau. Cela sera la base pour la suite.

Ensuite, on crée un Span à partir de ce tableau. On peut noter que la création est aisée grâce à une conversion implicite.

Il est ensuite facile de créer un sous-tableau. Ici, la variable subSpan est un tableau de 3 éléments débutant à partir de l'élément situé à l'index 4 (soit 5, 6, 7).

L'avantage donc, est que ce nouveau «tableau» n'a pas nécessité d'allocation! Et il y a même encore plus fort.

subSpan = 0;

Ici, on modifie le second élément de notre sous-tableau, pour l'initialiser à 0. Donc maintenant, le sous-tableau contient les éléments 5, 0, 7.

Mais si on regarde le tableau initial, on constate qu'il est également modifié, preuve qu'il n'y a pas de copie!

Comment ça marche? En fait, très simplement. Une structure Span contient une référence au tableau initial, à l'index de départ et à la taille du tableau. Ensuite, les méthodes de la structure font le nécessaire pour déterminer l'index dans le tableau initial pour les différents accès.

Et ce n'est pas fini! Span utilise une nouvelle notion introduite avec C# 7.2: les références sur les structures. Dit comme cela, cela reste un peu flou. Il faut se souvenir que les structures ne sont modifiables qu'à travers une variable. Il n'est pas possible de modifier directement une structure retournée par une fonction par exemple. Donnons un exemple plus concret, en abandonnant notre tableau d'entiers pour passer sur un tableau de structures:

public struct MyStruct
{
public int Value;
}

...

MyStruct[] array = {
new MyStruct() { Value = 1 },
new MyStruct() { Value = 2 },
new MyStruct() { Value = 3 }
};

Span span = array;
List list = new List(array);

span.Value = 42;
list.Value = 42; // Ne compile pas

Ici, à partir d'un tableau, j'ai initialisé un Span et une List, afin de bien mettre en évidence l'apport lié à l'usage des références sur les structures. Grâce à cela, il est possible de modifier directement une valeur, comme si c'était une variable. Si nous avions une List, cela ne serait pas possible et nous aurions une erreur à la compilation due au fait que l'indexeur d'une List renvoie une structure, qui ne peut donc pas être modifiée directement. Par contre, Span renvoie non pas une structure, mais une référence à la structure, qui peut donc être directement modifiée!

Mais du coup, cela impose quand même quelques limitations. En effet, afin de garder une gestion de la mémoire performante, une instance de Span ne peut être stockée que sur la pile et non sur le tas. De ce fait, il n'est pas possible d'utiliser un Span en tant qu'attribut d'une classe ou dans une expression lambda par exemple.

Dans la plupart des cas, cela n'est pas un véritable souci, car cette structure permet surtout d'optimiser des algorithmes via une gestion performante des sous-tableaux.

Mais il peut y avoir des cas où cela serait utile, notamment dans le cas de procédure asynchrone. Et c'est là que Memory entre en jeu.

Memory
Comme Span, Memory permet de stocker une référence à un tableau, à un indice de départ et à une longueur.
Par contre, contrairement à Span, il n'est pas possible d'accéder directement à un élément en particulier. Pour cela, il est nécessaire de convertir un Memory en Span, qu'il est ensuite possible d'utiliser classiquement. Et cela tombe bien, car justement, Memory dispose d'une propriété nommée Span permettant de réaliser cette opération de conversion!

ReadOnlySpan
Dans le cas où il n'est pas nécessaire de modifier le tableau initial, mais uniquement d'y accéder, il est possible d'utiliser un ReadOnlySpan. C'est comme Span sauf que les accès en écriture ne sont pas autorisés.

L'avantage, c'est que le ReadOnlySpan est compatible avec la classe String afin d'avoir un ReadOnlySpan. En effet, la classe string étant immutable, un string est non modifiable. C'est pourquoi la conversion d'un string en Span n'est pas possible.

Vous avez lu gratuitement 5 948 articles depuis plus d'un an.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.

Une erreur dans cette actualité ? Signalez-nous-la !

Votre nom : Votre e-mail :

Décrivez l'erreur que vous souhaitez porter à notre connaissance :

Identifiez-vous

Créer un compte

C# 7.2 : à la découverte des deux nouvelles fonctionnalités que sont Span<T> et Memory<T>

Un billet de François DORIN

Identifiant
Mot de passe

Mot de passe oublié ?

Identifiez-vous

Créer un compte

C# 7.2 : à la découverte des deux nouvelles fonctionnalités que sont Span<T> et Memory<T> Un billet de François DORIN

C# 7.2 : à la découverte des deux nouvelles fonctionnalités que sont Span<T> et Memory<T>

Un billet de François DORIN