Metody jsou funkce definované ve třídě. C# podporuje bohaté funkcionalitě parametrů — nepovinné/pojmenované argumenty, modifikátory ref/out/in, pole params — a (více metod se stejným názvem, ale různými parametry).
public int Add(int a, int b) => a + b; // expression-bodied (concise)
public string Greet(string name, string greeting = "Hello") // default parameter
{
return $"{greeting}, {name}";
}
Greet("Ann"); // "Hello, Ann"
Greet("Ann", greeting: "Hi"); // named argument
Metody určují návratový typ, název a parametry. Výchozí parametry činí argumenty nepovinné a pojmenované argumenty umožňují předávání podle názvu (jasnější, lze vynechat nepovinné).
// ref — pass by reference (method can modify the caller's variable)
void Increment(ref int x) { x++; }
int n = 5; Increment(ref n); // n is now 6
// out — for returning multiple values (must be assigned in the method)
bool TryParse(string s, out int result) { result = ...; return true; }
if (int.TryParse("42", out int value)) { } // the common TryX pattern
// in — pass by reference but READ-ONLY (performance for large structs)
void Process(in LargeStruct data) { }
out se hojně používá v TryParse patternu (vrácení příznaku úspěchu plus výsledek bezpečně); ref umožňuje modifikovat proměnnou volajícího; in efektivně předává velké struktury bez kopírování.
// params — variable number of arguments
int Sum(params int[] numbers) => numbers.Sum();
Sum(1, 2, 3, 4); // any number
// OVERLOADING — same name, different parameters
void Print(int x) { }
void Print(string s) { }
void Print(int x, int y) { }
Print(5); // calls the int version — resolved by argument types
Přetížení umožňuje více metodám sdílet název, rozlišeny typem/počtem parametrů — kompilátor vybere vyhovující metodu. params přijímá proměnný počet argumentů.
Metody jsou stavebními kameny chování v C#, a pochopení jejich bohatých parametrových funkcionalit je důležité pro psaní flexibilního a expresivního kódu.
Znalost definování metod (včetně stručné syntaxe s tělem výrazu), používání výchozích a pojmenovaných parametrů (pro nepovinné argumenty a čitelná volání) a aplikace přetížení metod (stejný název, různé parametry — pro intuitivní API, která zpracovávají různé typy argumentů) je každodenní znalostí.
Modifikátory parametrů jsou obzvláště důležité pochopit: out se hojně používá v všudypřítomném TryParse patternu (int.TryParse(s, out var result) — bezpečné vrácení příznaku úspěchu a výsledku bez výjimek, běžný, idiomatický C# pattern), ref umožňuje modifikovat proměnnou volajícího a in předává velké struktury odkazem pro výkon.
Pochopení těchto aspektů — metod, parametrových funkcionalit (nepovinné/pojmenované/params), přetížení pro flexibilní API a modifikátory ref/out/in (zvláště idiom založený na out v TryParse) — je zásadní jak pro psaní C# metod, tak pro používání mnoha .NET API, která se na tyto funkcionality opírají.
Protože metody a jejich parametry jsou ústředkem veškerého C# kódu a protože se funkcionality jako přetížení, nepovinné parametry a TryX pattern objevují neustále, jejich zvládnutí je základní, nezbytná znalost pro efektivní C# vývoj.