C# Academy · 课时

将元组作为方法返回值

Q: 「将元组作为方法返回值」这节课中我会学到什么？

无需 out 参数即可返回多个结果。 你通过在浏览器中直接运行的动手代码来练习 C# Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

无需 out 参数即可返回多个结果。

将元组作为方法返回值 是 CoddyKit 上的免费 C# Academy 课时。这是第 4 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 C# Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 C# Academy 课程共包含 4 节课。

返回多个值

方法只能返回一个结果，但元组可以让这个结果包含多个值，是 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);
    }
}

命名元组返回类型

为返回的元素命名可以让方法自我说明，也让调用位置更加易读。

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);
    }
}

解构返回值

调用方可以直接将返回的元组解构到多个独立变量中。

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);
    }
}

out 参数的替代方案

在元组出现之前，要返回额外结果就需要使用 out 参数。它们仍然可用，但声明和调用都更加繁琐。

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);
    }
}

元组与 out：可读性

元组返回值会将所有结果放在返回值中，并且可以通过解构自然地读取，因此在简单场景下通常优先于 out。

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);
    }
}

返回状态和值

一种常见模式是同时返回成功标志和结果，类似于尝试模式，但将两者组合在一个元组中。

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");
    }
}

out 仍然适用的场景

对于内置的尝试模式，out 仍然是惯用写法（int.TryParse）：一个布尔结果和一个 out 值是约定俗成的形式。

using System;

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

返回多个命名字段

元组可以扩展到多个结果，而不必强迫您创建一次性使用的类。

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);
    }
}

何时应优先使用类

如果组合的数据具有行为、会被广泛复用，或需要验证，请定义类或记录类型，而不是在各处都返回元组。

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);
    }
}

串联返回的元组

您可以通过内联解构，将返回的元组直接传给另一个计算过程。

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));
    }
}

综合运用

返回命名元组是从方法返回少量相关值的现代、易读方式，无需额外的繁琐代码。

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");
    }
}

快速检查

请测试您对元组返回值的理解。

回顾

返回元组可以让方法一次返回多个值，在大多数情况下比 out 更简洁。请为元素命名以提升清晰度，并让调用方对其进行解构。对于约定俗成的尝试模式，请保留 out；当数据具有行为或需要广泛复用时，请优先使用类或记录类型。

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);
    }
}

常见问题解答

「将元组作为方法返回值」课时是免费的吗？

是的 — 「将元组作为方法返回值」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 C# Academy 课程的其余内容，请升级到 CoddyKit PRO。 C# Academy 课程共包含 4 节课。

「将元组作为方法返回值」这节课中我会学到什么？

无需 out 参数即可返回多个结果。你通过在浏览器中直接运行的动手代码来练习 C# Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 C# Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 C# Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 4 节课，共 4 节。

「将元组作为方法返回值」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 C# Academy 课中编写并运行代码吗？

能。每节 C# Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

值元组基础
命名元组元素
解构
将元组作为方法返回值

← 返回 C# Academy