C# Academy · Lekcja

Krotki jako wartości zwracane metod

Zwracaj wiele wyników bez parametrów out.

Krotki jako wartości zwracane metod to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Zwracanie wielu wartości

Metoda może zwrócić tylko jedną rzecz, ale krotka pozwala zapakować w tę jedną rzecz kilka wartości, stanowiąc przejrzystą alternatywę dla parametrów 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);
    }
}

Nazwane typy zwracanych krotek

Nazwanie zwracanych elementów sprawia, że metoda sama opisuje swoje przeznaczenie, a miejsce jej wywołania jest czytelne.

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

Dekonstrukcja zwracanej wartości

Wywołujący może bezpośrednio zdekonstruować zwracaną krotkę do osobnych zmiennych.

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

Alternatywa w postaci parametru out

Zanim pojawiły się krotki, zwracanie dodatkowych wartości oznaczało użycie parametrów out. Nadal działają, ale ich deklarowanie i wywoływanie jest mniej wygodne.

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

Krotki a out: czytelność

Zwracanie krotki utrzymuje wszystkie wyniki w wartości zwracanej i naturalnie współpracuje z dekonstrukcją, dlatego w prostych przypadkach zwykle wybiera się je zamiast 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);
    }
}

Zwracanie stanu i wartości

Typowym wzorcem jest zwracanie obok wyniku flagi powodzenia, podobnie jak we wzorcu Try, ale zebranych w jednej krotce.

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

Kiedy out nadal jest przydatne

out nadal jest idiomatyczne we wbudowanym wzorcu Try (int.TryParse), w którym jedna wartość logiczna i jedna wartość out są konwencjonalnym rozwiązaniem.

using System;

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

Zwracanie kilku nazwanych pól

Krotki pozwalają zwracać wiele wyników bez konieczności tworzenia jednorazowej klasy.

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

Kiedy lepiej użyć klasy

Jeśli zgrupowane dane mają własne zachowanie, są szeroko wykorzystywane lub wymagają walidacji, zdefiniuj klasę albo rekord zamiast wszędzie zwracać krotkę.

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

Łączenie zwracanych krotek

Można przekazać zwracaną krotkę bezpośrednio do kolejnego obliczenia, wykonując dekonstrukcję w miejscu użycia.

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

Podsumowanie

Zwracanie nazwanej krotki to nowoczesny i czytelny sposób przekazywania z metody kilku powiązanych wartości bez zbędnej ceremonii.

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

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat wartości zwracanych w krotkach.

Podsumowanie

Zwracanie krotki pozwala metodzie przekazać jednocześnie kilka wartości i w większości przypadków jest przejrzystszym rozwiązaniem niż out. Dla większej czytelności nazwij elementy i pozwól wywołującemu je zdekonstruować. Zachowaj out dla konwencjonalnego wzorca Try, a gdy dane mają własne zachowanie lub są szeroko wykorzystywane, wybierz klasę albo rekord.

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

Często zadawane pytania

Czy lekcja „Krotki jako wartości zwracane metod” jest bezpłatna?

Tak — pełny tekst „Krotki jako wartości zwracane metod” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Krotki jako wartości zwracane metod”?

Zwracaj wiele wyników bez parametrów out. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Krotki jako wartości zwracane metod”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C# Academy