Metoder er funktioner defineret i en klasse. C# understøtter avancerede parameterfunktioner — valgfri/navngivne argumenter, ref/out/in modifikatorer, arrays — og (flere metoder med samme navn men forskellige parametre).
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
Metoder angiver en returtype, navn og parametre. Standardparametre gør argumenter valgfrie, og navngivne argumenter lader dig sende efter navn (tydeligere, kan springe valgfrie over).
// 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 bruges i vid udstrækning i TryParse-mønsteret (returnerer et succesflag plus resultatet sikkert); ref tillader ændring af kalderens variabel; in sender store strukturer effektivt uden kopiering.
// 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
Overloading tillader flere metoder at dele et navn, skelnet ved parametertyper/antal — compileren vælger den matchende. params accepterer et variabelt antal argumenter.
Metoder er byggestenene for adfærd i C#, og det er vigtigt at forstå deres avancerede parameterfunktioner for at skrive fleksibel, udtrykskraftig kode.
At vide, hvordan man definerer metoder (herunder kortfattet expression-bodied syntaks), bruger standardparametre og navngivne parametre (for valgfrie argumenter og læsbare kald), og anvender metodoverloading (samme navn, forskellige parametre — for intuitive API'er, der håndterer forskellige argumenttyper) er daglig viden.
Parametermodifikatorerne er især vigtige at forstå: out bruges i vid udstrækning i det allestedsnærværende TryParse-mønster (int.TryParse(s, out var result) — returnerer sikkert et succesflag og resultat uden undtagelser, et almindeligt, idiomatisk C#-mønster), ref muliggør ændring af kalderens variabel, og in sender store strukturer efter reference for ydeevne.
At forstå disse — metoder, parameterfunktionerne (valgfri/navngivne/params), overloading for fleksible API'er, og ref/out/in modifikatorerne (især out-baserede TryParse idiom) — er grundlæggende for både at skrive C#-metoder og at bruge de mange .NET API'er, der er afhængige af disse funktioner.
Da metoder og deres parametre er centrale for al C#-kode, og da funktioner som overloading, valgfrie parametre og TryX-mønsteret vises konstant, er det at mestre dem kerneviden, må-vide viden for effektiv C#-udvikling.