C# Academy · Lección

Tuplas como valores de retorno de métodos

Devuelva varios resultados sin parámetros out.

Tuplas como valores de retorno de métodos es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

Devolver varios valores

Un método solo puede devolver una cosa, pero una tupla permite que esa única cosa agrupe varios valores, una alternativa clara a los parámetros 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);
    }
}

Tipos de retorno de tupla con nombre

Asignar nombres a los elementos devueltos hace que el método se describa por sí mismo y que el punto de llamada sea más legible.

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

Deconstruir el retorno

Los consumidores pueden deconstruir directamente la tupla devuelta en variables independientes.

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

La alternativa del parámetro out

Antes de las tuplas, para devolver valores adicionales se utilizaban parámetros out. Funcionan, pero son menos prácticos de declarar y llamar.

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

Tuplas frente a out: legibilidad

Los retornos de tupla mantienen todos los resultados en el valor de retorno y se leen de forma natural mediante la deconstrucción, por lo que normalmente se prefieren a out en los casos sencillos.

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

Devolver un estado y un valor

Un patrón habitual consiste en devolver un indicador de éxito junto con el resultado, de forma similar al Try-pattern, pero agrupado en una sola tupla.

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

Cuándo sigue siendo útil out

out sigue siendo idiomático para el Try-pattern integrado (int.TryParse), en el que un resultado booleano y un valor out son convencionales.

using System;

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

Devolver varios campos con nombre

Las tuplas permiten devolver varios resultados sin obligarle a crear una clase específica para una sola ocasión.

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

Cuándo preferir una clase

Si los datos agrupados tienen comportamiento, se reutilizan ampliamente o necesitan validación, defina una clase o un record en lugar de devolver una tupla en todas partes.

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

Encadenar tuplas devueltas

Puede pasar una tupla devuelta directamente a otro cálculo deconstruyéndola en línea.

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

Unir todas las piezas

Devolver una tupla con nombre es la forma moderna y legible de devolver unos pocos valores relacionados desde un método sin ceremonias adicionales.

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

Comprobación rápida

Compruebe su comprensión de los valores de retorno de tuplas.

Resumen

Devolver una tupla permite que un método devuelva varios valores a la vez, una opción más clara que out en la mayoría de los casos. Asigne nombres a los elementos para mejorar la claridad y permita que los consumidores los deconstruyan. Reserve out para el Try-pattern convencional y prefiera una clase o un record cuando los datos tengan comportamiento o se reutilicen ampliamente.

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

Preguntas frecuentes

¿La lección «Tuplas como valores de retorno de métodos» es gratis?

Sí — el texto completo de «Tuplas como valores de retorno de métodos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tuplas como valores de retorno de métodos»?

Devuelva varios resultados sin parámetros out. Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Tuplas como valores de retorno de métodos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Conceptos básicos de las tuplas de valores
Elementos con nombre en tuplas
Deconstrucción
Tuplas como valores de retorno de métodos

← Volver a C# Academy