0 bodů

C# · 40 min

Metody

Jak psát metody v C#: parametry a návratové hodnoty, výrazová těla, výchozí hodnoty, přetěžování, ref a out, params, lokální funkce a rekurze.

Lidsky řečeno

Metoda je přístroj na výrobu džusu. Nasypeš dovnitř ovoce (parametry), zmáčkneš tlačítko (zavoláš metodu) a vyleze džus (návratová hodnota). Nemusíš znát vnitřek, stačí vědět, co dovnitř a co ven. A jeden přístroj použiješ stokrát, místo abys stokrát mačkal ručně.

Obtížnost: 3 z 5. Předpoklad: .NET 10 (LTS) a C# 14, kód funguje od .NET 8 / C# 12.

Deklarace a volání

Metoda má návratový typ, jméno a parametry. Typ void znamená, že nic nevrací. Výsledek vrací příkaz return:

csharp
int Square(int x) => x * x;

int Add(int a, int b)
{
    return a + b;
}

Console.WriteLine(Square(4));
Console.WriteLine(Add(Square(2), 3));
text
16
7

Zápis => u Square je výrazové tělo: místo bloku s return stačí jeden výraz. Argumenty se vyhodnotí před voláním, takže Add(Square(2), 3) je Add(4, 3).

Výchozí hodnoty a pojmenované argumenty

Parametr s výchozí hodnotou smíš při volání vynechat. Argumenty můžeš zadat i jménem, v libovolném pořadí:

csharp
string Greet(string name, string greeting = "Hello", bool shout = false)
{
    string text = $"{greeting}, {name}";
    return shout ? text.ToUpper() : text;
}

Console.WriteLine(Greet("Eva"));
Console.WriteLine(Greet("Eva", "Hi"));
Console.WriteLine(Greet("Eva", shout: true));
text
Hello, Eva
Hi, Eva
HELLO, EVA

Parametry s výchozí hodnotou musí být až na konci seznamu. Pojmenovaný argument shout: true přeskočí prostřední parametr greeting.

Přetěžování

Přetížení (overload) jsou metody se stejným jménem a různými parametry. Překladač vybere tu, která sedí na argumenty. Rozhoduje seznam parametrů, ne návratový typ:

csharp
Console.WriteLine(Calc.Max(3, 8));
Console.WriteLine(Calc.Max(2.0, 1));
Console.WriteLine(Calc.Max("pes", "kocka"));

static class Calc
{
    public static int Max(int a, int b) => a > b ? a : b;
    public static double Max(double a, double b) => a > b ? a : b;
    public static string Max(string a, string b) =>
        string.Compare(a, b) > 0 ? a : b;
}
text
8
2
pes

Volání Calc.Max(2.0, 1) má argumenty double a int. Verze pro int nepasuje (z double se nepřevádí implicitně na int), takže se použije verze pro double. Výsledek 2.0 se vypíše jako 2. Slovo static znamená, že metoda patří třídě, ne objektu. Víc o třídách přijde později.

ref a out

Parametry se normálně předávají hodnotou: metoda dostane kopii. Chceš-li, aby metoda změnila původní proměnnou, použij ref. Parametr out slouží k vrácení dalšího výsledku (proměnná nemusí mít hodnotu předem, ale metoda ji musí nastavit):

csharp
void Swap(ref int a, ref int b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

bool TryDivide(int a, int b, out int result)
{
    if (b == 0)
    {
        result = 0;
        return false;
    }
    result = a / b;
    return true;
}

int x = 1, y = 2;
Swap(ref x, ref y);
Console.WriteLine($"{x} {y}");

if (TryDivide(10, 3, out int q))
    Console.WriteLine(q);
Console.WriteLine(TryDivide(1, 0, out int z));
Console.WriteLine(z);
text
2 1
3
False
0

Vzor „vrať bool a výsledek přes out“ znáš z int.TryParse. Proměnná q vzniká přímo v zápisu out int q a je dostupná i za příkazem if. Víc výsledků najednou jde vrátit i n-ticí (tuple):

csharp
(int Min, int Max) MinMax(int[] values)
{
    int min = values[0];
    int max = values[0];
    foreach (int v in values)
    {
        if (v < min) min = v;
        if (v > max) max = v;
    }
    return (min, max);
}

var (lo, hi) = MinMax(new[] { 4, 9, 2, 7 });
Console.WriteLine($"{lo} {hi}");
text
2 9

params a rekurze

Klíčové slovo params dovolí předat libovolný počet argumentů, které se v metodě objeví jako pole. Rekurze je metoda, která volá sama sebe a musí mít ukončující podmínku:

csharp
int Sum(params int[] numbers)
{
    int total = 0;
    foreach (int n in numbers)
        total += n;
    return total;
}

long Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);

Console.WriteLine(Sum());
Console.WriteLine(Sum(1, 2, 3));
Console.WriteLine(Factorial(5));
Console.WriteLine(Factorial(20));
text
0
6
120
2432902008176640000

Návratový typ long je důležitý: 20! se do int nevejde. Faktoriál od 21 už přeteče i long.

Úskalí: předávání hodnotou a odkazem

Parametr typu int je kopie. U pole (referenční typ) se kopíruje odkaz, takže metoda změní původní data:

csharp
void AddOne(int n) { n++; }

void AddOneToAll(int[] arr)
{
    for (int i = 0; i < arr.Length; i++)
        arr[i]++;
}

int a = 5;
AddOne(a);
int[] nums = { 1, 2 };
AddOneToAll(nums);
Console.WriteLine($"{a} {nums[0]} {nums[1]}");
text
5 2 3

AddOne zvýšila jen svoji kopii, a proto zůstává a rovno 5. Pole nums se naopak změnilo, protože metoda dostala odkaz na totéž pole.

Procvič si to

Doplň

Co vypíšou ukázky z lekce?

Spoj dvojice

Spoj zápis s významem

Ke každému zápisu najdi, co dělá.

Roztřiď

ref, nebo out?

Roztřiď tvrzení podle toho, ke kterému klíčovému slovu patří.

Najdi chybu v tomto kódu:

csharp
int Sign(int x)
{
    if (x > 0) return 1;
    if (x < 0) return -1;
}
Kvíz

Proč se kód výše nepřeloží?

Kvíz

Co vypíše void AddOne(int n) { n++; } int a = 5; AddOne(a); Console.WriteLine(a);?

Kvíz

Která metoda je správné přetížení metody int Max(int a, int b)?

Pod kapotou · in, ref return a lokální funkce

Parametr in předá argument odkazem jen pro čtení, hodí se u velkých struktur, aby se nekopírovaly. ref lze použít i u návratové hodnoty (ref int Find(...)) a u lokálních proměnných. Lokální funkce může být static: pak nemůže používat proměnné okolního kódu, a překladač tak odhalí nechtěné zachycení. Lambda výrazy a delegáty (Func<int, int>) jsou stejný nápad v podobě hodnoty, kterou můžeš předat jiné metodě. Rekurze je v C# omezená velikostí zásobníku, tisíce úrovní zvládne, statisíce už ne. Od C# 13 jde u params použít i jiné kolekce než pole, třeba params ReadOnlySpan<int>.

Kartičky

Opakování: metody