1. Introduction
Imagine qu’on a une fonction qui, pour un utilisateur donné (genre par son nom), doit retourner à la fois l’âge, la date d’inscription et un flag d’activité. En C et dans les vieilles versions de C#, c’était normal de ne retourner qu’une seule valeur. Mais si on veut en retourner plusieurs ? Cette question a donné naissance à différentes approches, chacune avec ses avantages et ses inconvénients.
Dans les leçons précédentes, on a déjà vu les tuples. Maintenant, on va découvrir les out-paramètres et comparer ces deux méthodes.
Les approches les plus populaires :
- Utiliser les out-paramètres.
- Retourner un objet avec les champs nécessaires (type anonyme ou classe custom).
- Retourner un tuple (ValueTuple).
Dans cette leçon, on va regarder en détail deux de ces approches – les out-paramètres et les tuples, et on va les comparer "face à face" pour comprendre les avantages de chacune pour retourner plusieurs valeurs d’une fonction.
2. out-paramètres : un clin d’œil au passé
Quand tu vois une fonction du genre :
void GetUserInfo(string userName, out int age, out DateTime registrationDate, out bool isActive)
{
// ici des calculs
age = 42;
registrationDate = new DateTime(2010, 1, 1);
isActive = true;
}
tu te demandes : c’est une fonction ou une station de lavage auto miniature ? Il y a tellement de trucs qui sortent, et tout ça en dehors de la valeur de retour principale !
Comment ça marche
Le code appelant doit déclarer à l’avance les variables que la fonction va remplir :
int age;
DateTime reg;
bool isActive;
GetUserInfo("Bob", out age, out reg, out isActive);
// Maintenant toutes les variables sont remplies
Console.WriteLine($"{age}, {reg}, {isActive}");
Inconvénients de l’approche out
- Moins lisible : La signature de la méthode devient énorme, et le sens des données retournées n’est pas toujours clair juste avec les noms des paramètres.
- Pas pratique pour les chaînes d’appels : Tu ne peux pas facilement utiliser cette méthode dans une chaîne (genre passer le résultat direct à une autre méthode).
- Modifie les variables passées : La méthode doit modifier des variables existantes ; si tu oublies le out — erreur de compilation.
- Déclaration obligatoire : Le compilateur t’oblige à déclarer les variables externes, même si tu veux juste utiliser le résultat une seule fois.
- Lisibilité limitée dans les grosses méthodes : Si t’as plein de out-paramètres, tu peux vite t’emmêler sur qui est quoi et à quoi ça sert.
C’est là que les tuples commencent à briller de mille feux.
3. Les tuples — l’évolution de l’approche
Comparons avec un exemple
Avec un tuple :
public (int Age, DateTime RegistrationDate, bool IsActive) GetUserInfo(string userName)
{
// simulation d’une recherche en base
return (42, new DateTime(2010, 1, 1), true);
}
Utilisation :
// On récupère toutes les valeurs d’un coup et on donne des noms aux variables
var (age, regDate, isActive) = GetUserInfo("Bob");
Console.WriteLine($"{age}, {regDate}, {isActive}");
Pas besoin de déclarations en trop, pas de out, tout est super lisible !
Tableau comparatif : out vs tuple
| Critère | Paramètres Out | Tuples (ValueTuple) |
|---|---|---|
| Signature | longue, out-paramètres dans la liste | compacte, tout est retourné dans un seul "colis" |
| Utilisation | faut déclarer les variables puis appeler la méthode | tu peux déstructurer direct |
| Lisibilité | souvent perdue si y’a plusieurs out-paramètres | les noms des éléments sont clairs tout de suite |
| Facile à combiner ? | non | oui, tu peux imbriquer et transporter |
Tuples VS. out — ce qui se passe sous le capot
Avec les out-paramètres, la fonction bosse en fait avec la mémoire en dehors de sa "zone" : pour simplifier, elle modifie des variables créées ailleurs. Faut faire gaffe, parce que tu peux facilement "polluer" l’état des variables (merci au compilateur pour l’obligation d’assigner !).
Un tuple, par contre, c’est une structure de données que la fonction crée, initialise complètement et renvoie. Du coup, tout est dans un seul colis, que tu ne risques pas de perdre ou d’oublier.
Lire et maintenir le code
Avoue — quand tu relis le code de quelqu’un d’autre une semaine plus tard, tu préfères voir :
(var age, var city, var isActive) = GetUserInfo("Anna");
plutôt que
int age;
string city;
bool isActive;
GetUserInfo("Anna", out age, out city, out isActive);
Les tuples rendent les signatures des méthodes moins bruyantes, et le résultat est super intuitif à utiliser.
4. Situations où les tuples sont vraiment cool
1. Quand tu veux retourner un résultat et un message d’erreur
public (bool Success, string ErrorMessage) TryProcess(string data)
{
if (string.IsNullOrEmpty(data))
return (false, "Pas de données");
// traitement des données...
return (true, "");
}
var (ok, error) = TryProcess(input);
if (!ok)
Console.WriteLine($"Erreur : {error}");
2. Pour les fonctions qui retournent plusieurs résultats de recherche
public (User? FoundUser, int Index) FindUserByName(User[] users, string name)
{
for (int i = 0; i < users.Length; i++)
{
if (users[i].Name == name)
return (users[i], i);
}
return (null, -1);
}
3. Pour les “paires” de valeurs : calcul du minimum et du maximum
public (int min, int max) FindMinMax(int[] numbers)
{
int min = numbers[0], max = numbers[0];
foreach (var n in numbers)
{
if (n < min) min = n;
if (n > max) max = n;
}
return (min, max);
}
var (minValue, maxValue) = FindMinMax(arr);
GO TO FULL VERSION