.Net 4.0 : les Tuples

Ronald Vasseur

Voici quelques mois que le .Net Framework est disponible en version 4.0. Les Tuples sont une petite nouveauté parmi tant d'autres mais qui peuvent se révéler bien pratique dans de nombreuses situations. Je pense que chaque développeur .Net doit rencontrer ce problème quotidiennement ou presque : " ma méthode devrait retourner plusieurs valeurs en même temps, comment puis-je faire ? ". Microsoft a pensé à tous ces développeurs désespérés dans la version 4.0 du Framework et a créé les Tuples !

- Titre : .Net 4.0 : les Tuples

- Auteur : Ronald Vasseur

- Parution : 15 octobre 2010

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2010 Ronald Vasseur. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Un Tuple, qu'est-ce que c'est ?

- II. Un Tuple, comment ça marche ?

- III. Un Tuple, c'est bien ou pas ?

- IV. Ressources

- Liens vers le MSDN

- Liens vers Developpez.com

I - Un Tuple, qu'est-ce que c'est ?

Un Tuple est simplement un nouveau type .Net. C'est une structure de données qui permet de stocker ces valeurs d'un type définit dans un ordre définit. Le Tuple est, en quelque sorte, une boite qui permet de ranger des valeurs avant qu'une méthode ne les retourne. Ainsi une méthode qui va retourner un Tuple va pouvoir retourner simultanément jusqu'à huit valeurs, qui pourront être de n'importe quel type, pour peu que celui-ci soit un type .Net évidemment).

Un Tuple permet de stocker de une à huit valeurs de n'importe quel type. Pour les extrémistes du développement il sera toujours possible d'en renvoyer plus, en faisant en sorte qu'une de ces valeurs soit un Tuple qui a son tour va contenir potentiellement huit valeurs de plus… etc… Mais si vraiment vous avez besoin de retourner plus de huit valeurs, il y a de grande chance que votre application souffre d'un léger problème de design !

Microsoft .Net

Un Tuple permet de spécifier le type et la valeur qu'il va contenir, par contre il n'est pas possible de nommer une valeur comme on peut le faire avec un type anonyme par exemple. Petite remarque : tout l'intérêt du Tuple par rapport au type anonyme, c'est qu'une méthode peut retourner un Tuple (qui est fait pour cela) alors qu'une méthode ne peut pas retourner un type anonyme !

Tout cela pour dire qu'un Tuple permet de stocker de une à huit valeurs dans une structure de données en vue d'être retourné par une méthode.

II - Un Tuple, comment ça marche ?

Un Tuple est très simple à utiliser, il existe deux moyens d'instancier un tel objet : le constructeur ou une méthode statique de la classe System.Tuple.

Instancier un Tuple avec son constructeur

// Instancier un Tuple avec le constructeur
Tuple<String, String, Int16> infosClient1 = new Tuple<String, String, Int16>("Paul", "Durand", 1977););

Instancier un Tuple avec la méthode statique Create

// Instancier un Tuple avec la méthode statique Create
var infosClient2 =  Tuple.Create<String, String, Int16>("Paul", "Durand", 1977);

Les Tuples sont par nature " read-only ", il ne faut donc pas espérer pouvoir en manipuler le contenu après instanciation. Lors de l'instanciation du Tuple on spécifie le nombre de valeurs qu'il va contenir (de une à huit) simplement en spécifiant le type de chacune des valeurs l'on spécifie également, les valeurs elles-mêmes à ce moment.

Pour accéder aux valeurs stockées dans un Tuple il faut accéder aux propriétés qui les contiennent. Ces propriétés sont nommées Item1, Item2, Item3 et ainsi de suite en fonction de leur position dans le Tuple. Voici un exemple permettant de récupérer des valeurs contenues dans un Tuple :

Accéder aux valeurs contenues dans un Tuple

// Instancier un Tuple avec le constructeur
Tuple<String, String, Int16> infosClient1 = new Tuple<String, String, Int16>("Paul", "Durand", 1977);

// Récupérer les valeurs contenues dans un Tuple
String prenom = infosClient1.Item1;
String nom = infosClient1.Item2;
Int16 anneeNaissance = infosClient1.Item3;

// Même si chaque Item est typé il faut etre prudent notamment quand il y a beaucoup de valeurs, surtout du même type,
// le système de nommé les valeurs Item1, Item2, Item3 est assez peu pratique.

Si vous souhaitez comparer deux Tuple c'est tout à fait possible mais il faut faire attention à la manière de procéder. La méthode Equals d'un Tuple permet de comparer deux Tuples entre eux. La méthode va comparer chaque valeur, une à une, et retourner vrai si les données contenus sont identiques. Par contre la comparaison de deux Tuples en utilisant == ne fonctionnera pas.

Comparer deux Tuple

// Comment comparer deux Tuples ?

// La méthode qui fonctionne :
// Les valeurs vont être comparées une à une
if (infosClient1.Equals(infosClient2))
{
Console.WriteLine("Ces deux Tuples sont identiques !");
}
else
{
Console.WriteLine("Ces deux Tuples sont différents !");
}

// La méthode qui NE FONCTIONNE PAS :
// Comparer deux Tuples
if (infosClient1 == infosClient2)
{
Console.WriteLine("Ces deux Tuples sont identiques !");
}
else
{
Console.WriteLine("Ces deux Tuples sont différents !");
}

III - Un Tuple, c'est bien ou pas ?

Tout d'abord même si la classe Tuple nous apporte un petit plus il était déjà possible de faire à peu près la même chose en utilisant des ArrayList ou des KeyValuePair de dictionnaire, bref en " bidouillant " un peu on y arrivait, mais c'était parfois pas très propre ou pas très performant dans le cas d'ArrayList. Cependant cet objet est fait pour cela, donc autant l'utiliser.

Bien que dans son ensemble j'apprécie cet objet j'ai cependant quelques petits reproches à lui faire. Tout d'abord il n'est pas très simple à instancier, ça fait beaucoup de code à écrire, certains langages font beaucoup mieux que C# pour instancier des Tuples, je trouve cela un peu trop verbeux.

Ensuite, l'accès aux valeurs par Item1, Item2… je ne trouve pas cela très esthétique, mais surtout pas très pratique, surtout si on a huit valeurs dans le Tuple, le fait de pouvoir utiliser des noms comme dans les types anonymes aurait été un plus.

Enfin, dernier reproche, on ne peut pas itérer sur un Tuple, certes ce n'est pas dramatique vu les huit valeurs maximales, mais quand même cela aurait pu éviter du code un peu trop long et répétitif dans certaines situations.

En dehors de ces petits problèmes le Tuple est plutôt plaisant à utiliser et nous fait gagner pas mal de temps. La Tuple est un de ces objets qui ne sont pas indispensables, mais qui rendent la vie du développeur plus facile, il faut juste faire attention à ne pas l'utiliser dans certaines situations, ou le fait de devoir retourner plusieurs valeurs est un problème de design du code et non un vrai besoin, mais cela ne se limite pas au Tuple mais à tous les objets quels qu'ils soient. C'est une très bonne chose que Microsoft se soit enfin décidé à les intégrer au Framework .Net, d'autant plus que de nombreuses autres technologies et langages intègrent ce type d'objets depuis longtemps !

IV - Ressources

Liens vers le MSDN

La classe Tuple
La méthode Create<T1, T2>(T1, T2)

Liens vers Developpez.com

Mes articles
Mon blog
Les articles des autres rédacteurs
La rubrique .Net de Developpez.com