Parametry, przeciążanie i przekazywanie danych

Czego się dziś nauczysz

Przygotowanie: lekcje 01–19. Przewidywany czas: 45–90 minut z zadaniami. Przykłady wymagają .NET 8 lub nowszego, z włączonymi ImplicitUsings i Nullable.

Metoda dostaje kopię, nie zmienną

Parametr metody to osobna zmienna, która przy wywołaniu dostaje kopię przekazanej wartości. Zmiana parametru w środku metody nie dotyka zmiennej z miejsca wywołania.

static void Wyzeruj(int liczba)
{
    liczba = 0;                  // zmienia TYLKO lokalna kopie
    Console.WriteLine($"w metodzie: {liczba}");
}

static void Main()
{
    int punkty = 18;
    Wyzeruj(punkty);
    Console.WriteLine($"w Main:     {punkty}");
}

w metodzie: 0
w Main:     18

To samo dotyczy napisów, znaków, liczb rzeczywistych i wartości logicznych — czyli wszystkiego, co poznałeś do tej pory.

ref, out i in — kiedy metoda sięga do zmiennej

ref — praca na tej samej zmiennej

Słowo ref mówi: „nie kopiuj, daj dostęp do oryginału”. Piszemy je dwa razy — w deklaracji metody i przy wywołaniu.

static void Zwieksz(ref int liczba)
{
    liczba = liczba + 1;
}

static void Main()
{
    int licznik = 5;
    Zwieksz(ref licznik);
    Console.WriteLine(licznik);   // 6
}

Zmienna przekazywana przez ref musi mieć wartość przed wywołaniem — metoda ma prawo ją odczytać.

out — metoda ma coś zapisać

out działa podobnie, ale w jedną stronę: metoda musi przypisać wartość do takiego parametru, zanim się zakończy. Zmienna przed wywołaniem może być pusta.

static void PodzielZReszta(int a, int b, out int calosc, out int reszta)
{
    calosc = a / b;
    reszta = a % b;
}

static void Main()
{
    PodzielZReszta(17, 5, out int c, out int r);
    Console.WriteLine($"{c} reszty {r}");   // 3 reszty 2
}

Znasz to z lekcji 11: int.TryParse(tekst, out int liczba) zwraca bool — czy się udało — a samą liczbę oddaje przez out. Teraz wiesz, dlaczego tak wygląda.

in — tylko do odczytu

static double Pole(in double bok)
{
    // bok = 5;   // BLAD: parametru in nie wolno zmieniac
    return bok * bok;
}

Parametry opcjonalne i argumenty nazwane

static void Zamow(string produkt, int sztuki = 1, bool pilne = false)
{
    Console.WriteLine($"{produkt} x{sztuki}, pilne: {pilne}");
}

static void Main()
{
    Zamow("mysz");                          // mysz x1, pilne: False
    Zamow("klawiatura", 3);                 // klawiatura x3, pilne: False
    Zamow("monitor", 2, true);              // monitor x2, pilne: True
    Zamow("kabel", pilne: true);            // kabel x1, pilne: True
}

• Parametry z wartością domyślną muszą stać na końcu listy — inaczej kompilator nie wiedziałby, który argument pominięto.
• Wartość domyślna musi być stałą znaną przy kompilacji: liczba, napis, true, null.
• Argument nazwany (pilne: true) pozwala pominąć środkowy parametr i przy okazji czyni wywołanie czytelnym. Porównaj Zamow("monitor", 2, true) z Zamow("monitor", sztuki: 2, pilne: true).

Ta sama nazwa, różne listy parametrów

Przeciążenie to kilka metod o tej samej nazwie, różniących się liczbą albo typami parametrów. Kompilator wybiera właściwą po argumentach wywołania.

static int Pole(int bok)                    => bok * bok;
static int Pole(int szerokosc, int dlugosc) => szerokosc * dlugosc;
static double Pole(double promien)          => 3.14159 * promien * promien;

Console.WriteLine(Pole(3));        // 9    - kwadrat
Console.WriteLine(Pole(3, 4));     // 12   - prostokat
Console.WriteLine(Pole(2.0));      // 12,56636 - kolo

Zapis => to skrócona postać metody składającej się z jednej instrukcji return. Znaczy dokładnie to samo co { return bok * bok; }.

Przeciążanie znasz z praktyki: Console.WriteLine przyjmuje liczbę, napis, znak i wartość logiczną, bo istnieje kilkanaście jego przeciążeń.

Gdzie sięga zmienna

Zmienna zadeklarowana w metodzie istnieje tylko w niej i znika po jej zakończeniu. Dwie metody mogą mieć zmienne o tej samej nazwie — to dwie różne zmienne.

static void Pierwsza()
{
    int licznik = 1;
    Console.WriteLine(licznik);
}

static void Druga()
{
    int licznik = 100;      // inna zmienna, ta sama nazwa - to w porzadku
    Console.WriteLine(licznik);
    // Console.WriteLine(punkty);  // BLAD: 'punkty' nie istnieje w tej metodzie
}

static void Main()
{
    int punkty = 5;
    Pierwsza();
    Druga();
}

Przykład: kalkulator zamówień

class Program
{
    static double Netto(double cena, int sztuki = 1)
    {
        return cena * sztuki;
    }

    static double Netto(double cena, int sztuki, double rabatProcent)
    {
        return Netto(cena, sztuki) * (1 - rabatProcent / 100);
    }

    static void ZBrutto(double netto, out double vat, out double brutto)
    {
        vat = netto * 0.23;
        brutto = netto + vat;
    }

    static void Zamien(ref double a, ref double b)
    {
        double pomoc = a;
        a = b;
        b = pomoc;
    }

    static void Main()
    {
        double bez = Netto(120.0, 3);
        double zRabatem = Netto(120.0, 3, 10);

        Console.WriteLine($"bez rabatu : {bez:F2}");
        Console.WriteLine($"z rabatem  : {zRabatem:F2}");

        ZBrutto(zRabatem, out double vat, out double brutto);
        Console.WriteLine($"VAT        : {vat:F2}");
        Console.WriteLine($"brutto     : {brutto:F2}");

        double tania = 10, droga = 990;
        Zamien(ref tania, ref droga);
        Console.WriteLine($"po zamianie: {tania:F2} i {droga:F2}");
    }
}

bez rabatu : 360,00
z rabatem  : 324,00
VAT        : 74,52
brutto     : 398,52
po zamianie: 990,00 i 10,00

Co dzieje się po kolei

• Dwa przeciążenia Netto różnią się liczbą parametrów. Drugie wywołuje pierwsze zamiast powtarzać mnożenie — poprawka wzoru wystarczy w jednym miejscu.
• Netto(120.0, 3) korzysta z jawnie podanej liczby sztuk; Netto(120.0) użyłoby wartości domyślnej 1.
• ZBrutto oddaje dwa wyniki — dlatego out, a nie return. Zapis out double vat deklaruje zmienną wprost w wywołaniu.
• Zamien to podręcznikowe zastosowanie ref: bez niego zamiana zaszłaby tylko w lokalnych kopiach i nic nie byłoby widać.

Zestawienie elementów

Zanim utkniesz

Zadania

Co trzeba zapamiętać

• Parametr to kopia — zmiana parametru nie dotyka zmiennej wywołującego.
• ref daje dostęp do oryginału; słowo piszemy w deklaracji i przy wywołaniu.
• out służy do oddania dodatkowego wyniku i musi zostać przypisany w metodzie.
• Parametry opcjonalne stoją na końcu listy, a argument nazwany pozwala pominąć środkowy.
• Przeciążenia różnią się liczbą lub typami parametrów — nigdy samym typem wyniku.
• Zmienne zadeklarowane w metodzie nie istnieją poza nią; dane przekazujemy parametrami i zwracamy przez return.

Dokumentacja: Microsoft Learn — temat tej lekcji.