C# Academy · Leçon

Tuples comme valeurs de retour de méthodes

Renvoyez plusieurs résultats sans paramètres out.

Tuples comme valeurs de retour de méthodes est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 4 leçons au total.

Renvoyer plusieurs valeurs

Une méthode ne peut renvoyer qu'une seule chose, mais un tuple permet à cette chose de regrouper plusieurs valeurs, offrant une alternative claire aux paramètres out.

using System;

class Program
{
    static (int, int) Divide(int a, int b) => (a / b, a % b);

    static void Main()
    {
        var result = Divide(17, 5);
        Console.WriteLine(result.Item1 + " r " + result.Item2);
    }
}

Types de retour de tuples nommés

Nommer les éléments renvoyés rend la méthode explicite et l'appel lisible.

using System;

class Program
{
    static (int Quotient, int Remainder) Divide(int a, int b)
    {
        return (a / b, a % b);
    }

    static void Main()
    {
        var r = Divide(17, 5);
        Console.WriteLine("Q=" + r.Quotient + ", R=" + r.Remainder);
    }
}

Déconstruire la valeur renvoyée

Les appelants peuvent déconstruire directement le tuple renvoyé dans plusieurs variables.

using System;

class Program
{
    static (double Min, double Max) Bounds(double[] data)
    {
        double min = data[0], max = data[0];
        foreach (var d in data)
        {
            if (d < min) min = d;
            if (d > max) max = d;
        }
        return (min, max);
    }

    static void Main()
    {
        var (lo, hi) = Bounds(new double[] { 3, 7, 1, 9, 4 });
        Console.WriteLine("min=" + lo + ", max=" + hi);
    }
}

L'alternative du paramètre out

Avant les tuples, renvoyer des valeurs supplémentaires nécessitait des paramètres out. Ils fonctionnent, mais sont plus lourds à déclarer et à appeler.

using System;

class Program
{
    static int Divide(int a, int b, out int remainder)
    {
        remainder = a % b;
        return a / b;
    }

    static void Main()
    {
        int rem;
        int q = Divide(17, 5, out rem);
        Console.WriteLine("Q=" + q + ", R=" + rem);
    }
}

Tuples ou out : lisibilité

Les retours de tuples regroupent tous les résultats dans la valeur renvoyée et se lisent naturellement avec la déconstruction ; ils sont donc généralement préférables à out dans les cas simples.

using System;

class Program
{
    static (int Sum, int Count) Stats(int[] nums)
    {
        int sum = 0;
        foreach (var n in nums) sum += n;
        return (sum, nums.Length);
    }

    static void Main()
    {
        var (sum, count) = Stats(new[] { 2, 4, 6 });
        Console.WriteLine("Sum=" + sum + ", Count=" + count);
    }
}

Renvoyer un état et une valeur

Un schéma courant consiste à renvoyer un indicateur de réussite avec le résultat, à la manière du modèle de tentative, mais regroupés dans un seul tuple.

using System;

class Program
{
    static (bool Ok, int Value) ParseAge(string s)
    {
        if (int.TryParse(s, out int n) && n >= 0)
            return (true, n);
        return (false, 0);
    }

    static void Main()
    {
        var r = ParseAge("42");
        Console.WriteLine(r.Ok ? "Parsed " + r.Value : "Invalid");
    }
}

Quand out reste utile

out reste idiomatique pour le modèle de tentative intégré (int.TryParse), dans lequel un résultat booléen et une valeur out sont conventionnels.

using System;

class Program
{
    static void Main()
    {
        if (int.TryParse("100", out int value))
            Console.WriteLine("Got " + value);
        else
            Console.WriteLine("Not a number");
    }
}

Renvoyer plusieurs champs nommés

Les tuples permettent de gérer plusieurs résultats sans vous obliger à créer une classe ponctuelle.

using System;

class Program
{
    static (int Min, int Max, double Avg) Analyze(int[] nums)
    {
        int min = nums[0], max = nums[0], sum = 0;
        foreach (var n in nums)
        {
            if (n < min) min = n;
            if (n > max) max = n;
            sum += n;
        }
        return (min, max, (double)sum / nums.Length);
    }

    static void Main()
    {
        var a = Analyze(new[] { 4, 8, 2, 6 });
        Console.WriteLine("min=" + a.Min + ", max=" + a.Max + ", avg=" + a.Avg);
    }
}

Quand préférer une classe

Si les données regroupées ont un comportement, sont largement réutilisées ou nécessitent une validation, définissez plutôt une classe ou un enregistrement que de renvoyer un tuple partout.

using System;

class Program
{
    // Fine as a tuple: small, local, no behavior
    static (int W, int H) ParseSize(string s)
    {
        var parts = s.Split('x');
        return (int.Parse(parts[0]), int.Parse(parts[1]));
    }

    static void Main()
    {
        var (w, h) = ParseSize("16x9");
        Console.WriteLine(w + " by " + h);
    }
}

Enchaîner des tuples renvoyés

Vous pouvez transmettre directement un tuple renvoyé à un autre calcul en le déconstruisant sur place.

using System;

class Program
{
    static (int, int) Split(int total) => (total / 2, total - total / 2);

    static void Main()
    {
        var (a, b) = Split(7);
        Console.WriteLine("Halves: " + a + " + " + b + " = " + (a + b));
    }
}

Mise en pratique

Renvoyer un tuple nommé est la manière moderne et lisible de renvoyer quelques valeurs liées depuis une méthode, sans formalités supplémentaires.

using System;

class Program
{
    static (bool Found, int Index) Search(int[] arr, int target)
    {
        for (int i = 0; i < arr.Length; i++)
            if (arr[i] == target) return (true, i);
        return (false, -1);
    }

    static void Main()
    {
        var r = Search(new[] { 5, 8, 12 }, 8);
        Console.WriteLine(r.Found ? "At index " + r.Index : "Not found");
    }
}

Vérification rapide

Vérifiez votre compréhension des valeurs de retour des tuples.

Récapitulatif

Renvoyer un tuple permet à une méthode de renvoyer plusieurs valeurs à la fois, ce qui est généralement plus clair que out. Nommez les éléments pour plus de clarté et laissez les appelants les déconstruire. Réservez out au modèle de tentative conventionnel et préférez une classe ou un enregistrement lorsque les données ont un comportement ou sont largement réutilisées.

using System;

class Program
{
    static (int Sum, int Max) Go(int[] n)
    {
        int s = 0, m = n[0];
        foreach (var x in n) { s += x; if (x > m) m = x; }
        return (s, m);
    }

    static void Main()
    {
        var (sum, max) = Go(new[] { 3, 9, 5 });
        Console.WriteLine(sum + " / " + max);
    }
}

Questions Fréquemment Posées

La leçon « Tuples comme valeurs de retour de méthodes » est-elle gratuite ?

Oui — le texte complet de « Tuples comme valeurs de retour de méthodes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tuples comme valeurs de retour de méthodes » ?

Renvoyez plusieurs résultats sans paramètres out. Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Tuples comme valeurs de retour de méthodes » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Bases des tuples de valeurs
Éléments nommés des tuples
Déconstruction
Tuples comme valeurs de retour de méthodes

← Retour à C# Academy