1. Nommer les tuples : contexte pour la déconstruction
Dans la leçon précédente, on a déjà vu les tuples avec des éléments nommés, ce qui rend le code carrément plus lisible, parce qu’on accède aux valeurs non pas via des Item1, Item2 anonymes, mais avec des noms qui ont du sens (genre person.Name). Pouvoir donner des noms aux éléments d’un tuple, c’est super important surtout quand tu les utilises comme valeurs de retour de méthodes, paramètres ou propriétés. C’est justement le nommage qui rend la déconstruction pratique, et c’est ce qu’on va voir dans cette leçon.
Petit rappel : tu peux donner des noms aux éléments d’un tuple lors de son initialisation via un littéral, mais aussi dans la signature de retour d’une méthode, d’une propriété ou d’un champ.
Exemple avec une méthode : Éléments nommés dans la valeur de retour d’une méthode
public static (int Age, string Name) GetPetInfo()
{
return (Age: 5, Name: "Barsik");
}
// Utilisation :
var info = GetPetInfo();
Console.WriteLine($"{info.Name} — {info.Age} ans");
Exemple avec un champ/propriété : Éléments nommés dans un champ/propriété
public (int Width, int Height) ImageSize = (1024, 768);
À retenir : si tu ne donnes pas de noms explicites, les éléments restent accessibles via Item1, Item2 et ainsi de suite. Ça peut rendre le code moins lisible, surtout si tu utilises le tuple plus loin. C’est pour ça qu’il vaut mieux toujours donner des noms explicites aux éléments, sauf si leur sens est évident dans le contexte.
2. Déconstruction des tuples
C’est quoi la déconstruction ?
La déconstruction, c’est le fait de "décomposer" un tuple en variables séparées, pour bosser plus facilement avec. Par exemple, à partir du tuple (Age: 5, Name: "Barsik") tu peux obtenir deux variables : age et name.
Petite analogie : Imagine que le tuple, c’est une boîte avec des cases étiquetées. La déconstruction, c’est quand tu poses direct le contenu de chaque case à sa place sur la table.
Syntaxe de la déconstruction
var pet = (Age: 5, Name: "Barsik");
var (age, name) = pet;
Console.WriteLine($"{name} — {age} ans");
Maintenant on a deux variables : age et name. Elles prennent les valeurs du tuple. Les noms à gauche (age, name) n’ont pas besoin d’être les mêmes que dans le tuple, ce sont juste de nouvelles variables locales.
Déconstruction de la valeur de retour d’une fonction
Souvent, on utilise les tuples pour retourner plusieurs valeurs d’une fonction. Là, la déconstruction est super pratique :
public static (double min, double max) GetMinMax(int[] data)
{
int min = data.Min();
int max = data.Max();
return (min, max);
}
var numbers = new[] { 1, 2, 3, 4, 5 };
var (minValue, maxValue) = GetMinMax(numbers);
Console.WriteLine($"Minimum : {minValue}, maximum : {maxValue}");
À noter que lors de la déconstruction, tu peux nommer les variables comme tu veux selon le contexte.
Déconstruction avec var
var (a, b) = (10, 20); // int a = 10, b = 20
Déconstruction et discard _
Parfois, t’as pas besoin de tous les éléments du tuple. Tu peux les ignorer avec _ (discard). Le discard (_) dans un tuple, c’est juste une façon de dire « je sais qu’il y a un autre élément ici, mais j’en veux pas, crée pas de variable pour ».
Du coup, tu déstructures le tuple mais tu laisses un "trou" là où t’as pas besoin de la valeur. C’est concis, pratique et sans prise de tête !
var pet = (Age: 5, Name: "Barsik", IsHappy: true);
var (age, _, isHappy) = pet; // juste age et isHappy, le nom est ignoré
Fun fact : le discard est super utilisé pour éviter de polluer l’espace de noms avec des variables inutiles.
Déconstruction dans une boucle foreach
En C#, tu peux parcourir un tableau de tuples et déstructurer direct dans le foreach :
var pets = new (string Name, int Age)[]
{
("Barsik", 5),
("Musya", 3),
("Djonni", 7)
};
foreach (var (name, age) in pets)
{
Console.WriteLine($"{name} — {age} ans");
}
3. Comment fonctionnent les noms d’éléments et le typage
Comportement des éléments nommés
Les noms des éléments d’un tuple, c’est du "syntactic sugar", donc juste pour nous simplifier la vie. À la compilation, les noms deviennent des champs internes Item1, Item2, etc., mais l’IDE et le compilateur gardent les noms pour que tu puisses les utiliser.
Impact sur la compatibilité des types et le cast
Deux tuples avec le même nombre d’éléments et les mêmes types, mais des noms différents, sont considérés comme le même type par le compilateur. Les noms des éléments ne font pas partie de la définition du type :
var t1 = (X: 42, Y: 13);
var t2 = (A: 42, B: 13);
t1 = t2; // OK
Console.WriteLine(t1.X); // 42
Mais quand tu bosses avec des expressions et les suggestions IntelliSense, ce sont les noms de la partie gauche (celle à laquelle tu assignes) qui sont utilisés, pas ceux de droite.
Nommer explicitement ou non
On l’a déjà vu, mais au cas où : tu peux créer des tuples avec des éléments partiellement nommés, ou pas du tout — dans ce cas, ce sera juste Item1 et ainsi de suite.
var point = (X: 10, 20); // X et Item2
Console.WriteLine(point.X); // 10
Console.WriteLine(point.Item2); // 20
Conseil : nomme toujours les éléments si ton tuple a plus d’un ou deux éléments, ou si la signification de la valeur n’est pas claire dans le contexte.
4. Erreurs classiques et particularités avec les noms et la déconstruction
Erreur n°1 : « migration » des noms lors de l’assignation de tuples différents
Si tu déclares d’abord un tuple avec certains noms, puis tu lui assignes un autre tuple sans noms (ou avec d’autres noms), dans IntelliSense tu verras quand même les noms d’origine. Exemple :
var original = (X: 1, Y: 2);
var alias = original; // alias.X == 1, alias.Y == 2
original = (10, 20); // tuple sans noms
Console.WriteLine(alias.X); // ça marche toujours, mais alias garde les anciens noms
Erreur n°2 : doublon de noms d’éléments.
Tu peux pas donner le même nom à deux éléments — le compilateur va te sortir « Duplicate tuple element name » :
var badTuple = (A: 1, A: 2); // Erreur CS8122 : Duplicate tuple element name 'A'
Erreur n°3 : mauvaise déconstruction sur le nombre d’éléments.
Quand tu déstructures, le nombre de variables doit correspondre exactement à la taille du tuple. Sinon, erreur :
var pet = (Age: 5, Name: "Barsik");
var (age, name, mood) = pet; // Erreur CS8124 : Tuple must contain exactly 3 elements
Erreur n°4 : mauvaise utilisation du discard _
Ignorer des éléments avec _ marche pour chaque position séparément et ne « fusionne » pas les trous. Par exemple, si tu essaies de sauter deux éléments avec un seul _, tu auras une erreur :
var data = (1, 2, 3);
var (_, x, _) = data; // OK : on saute le premier et le troisième
var (_, _) = data; // Erreur CS8124 : Tuple must contain exactly 2 elements
GO TO FULL VERSION