CodeGym /Cours /C# SELF /Nommer les éléments et déconstruction des tuples

Nommer les éléments et déconstruction des tuples

C# SELF
Niveau 11, Leçon 2
Disponible

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");
Déconstruction d’un tuple en variables

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}");
Déconstruction de la valeur de retour d’une fonction

À 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é
Déconstruction avec discard _

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");
}
Déconstruction des tuples dans foreach

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
Compatibilité des tuples avec des noms d’éléments différents

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
Tuple partiellement nommé

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

2
Mission
C# SELF, niveau 11, leçon 2
Bloqué
Création d'un tuple nommé et affichage de ses éléments
Création d'un tuple nommé et affichage de ses éléments
2
Mission
C# SELF, niveau 11, leçon 2
Bloqué
Déconstruction de la valeur de retour d'une méthode
Déconstruction de la valeur de retour d'une méthode
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION