CodeGym /Cours /C# SELF /Retourner plusieurs valeurs depuis une fonction : paramèt...

Retourner plusieurs valeurs depuis une fonction : paramètres out et tuples

C# SELF
Niveau 11, Leçon 3
Disponible

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);
2
Mission
C# SELF, niveau 11, leçon 3
Bloqué
Création d'une fonction utilisant un tuple
Création d'une fonction utilisant un tuple
2
Mission
C# SELF, niveau 11, leçon 3
Bloqué
Calcul du minimum et du maximum avec un tuple
Calcul du minimum et du maximum avec un tuple
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION