Metodele sunt funcții definite într-o clasă. C# suportă caracteristici bogate de parametri — argumente opționale/numite, modificatori ref/out/in, tablouri — și (mai multe metode cu același nume dar parametri diferiți).
paramspublic 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
Metodele specifică un tip de întoarcere, un nume și parametri. Parametrii impliciti fac argumentele opționale, iar argumentele numite vă permit să transmigeți după nume (mai clar, puteți sări peste opționale).
// 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 este utilizat pe scară largă în modelul TryParse (returnând o steag de succes plus rezultatul în siguranță); ref permite modificarea variabilei apelantului; in transmite structuri mari eficient fără copiere.
// 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
Supraîncărcarea permite mai multor metode să partajeze un nume, distinse după tipuri/numărul parametrilor — compilatorul alege pe cea potrivită. params acceptă un număr variabil de argumente.
Metodele sunt blocurile de construcție ale comportamentului în C#, iar înțelegerea caracteristicilor bogate ale parametrilor lor este importantă pentru scrierea codului flexibil și expresiv.
Cunoașterea modului de definire a metodelor (inclusiv sintaxa concisă cu expresii în corp), utilizarea parametrilor impliciti și numiți (pentru argumente opționale și apeluri lizibile), și aplicarea supraîncărcării metodelor (același nume, parametri diferiți — pentru API-uri intuitive care gestionează diferite tipuri de argumente) este cunoaștere din zi cu zi.
Modificatorii de parametri sunt deosebit de importanți de înțeles: out este utilizat pe scară largă în modelul omniprezent TryParse (int.TryParse(s, out var result) — returnând în siguranță un steag de succes și rezultat fără excepții, un model comun și idiomul C#), ref permite modificarea variabilei apelantului, și in transmite structuri mari prin referință pentru performanță.
Înțelegerea acestora — metodele, caracteristicile parametrilor (opțional/numite/params), supraîncărcarea pentru API-uri flexibile, și modificatorii ref/out/in (în special idiomul bazat pe out TryParse) — este fundamentală atât pentru scrierea de metode C# cât și pentru utilizarea multelor API-uri .NET care se bazează pe aceste caracteristici.
Deoarece metodele și parametrii lor sunt centrali pentru tot codul C#, și din moment ce caracteristici cum ar fi supraîncărcarea, parametrii opționali, și modelul TryX apar constant, stăpânirea acestora este cunoaștere esențială, obligatorie pentru dezvoltarea eficientă în C#.