Methoden sind Funktionen, die in einer Klasse definiert sind. C# bietet umfangreiche Parameterfeatures – optionale/benannte Argumente, ref/out/in Modifizierer, Arrays – und (mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parametern).
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
Methoden geben einen Rückgabetyp, einen Namen und Parameter an. Standardparameter machen Argumente optional, und benannte Argumente ermöglichen es, nach Namen zu übergeben (übersichtlicher, können optionale Parameter überspringen).
// 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 wird häufig im TryParse-Muster verwendet (Rückgabe eines Erfolgssignals und des Ergebnisses auf sichere Weise); ref ermöglicht es, die Variable des Aufrufers zu ändern; in übergibt große Strukturen effizient ohne zu kopieren.
// 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
Überladung ermöglicht es, dass mehrere Methoden einen Namen teilen, unterschieden nach Parametertypen/Anzahl – der Compiler wählt die passende aus. params akzeptiert eine variable Anzahl von Argumenten.
Methoden sind die Bausteine des Verhaltens in C#, und das Verständnis ihrer umfangreichen Parameterfeatures ist wichtig für das Schreiben von flexiblem, ausdrucksstarkem Code.
Das Wissen, wie man Methoden definiert (einschließlich prägnanter ausdrucksgesteuerter Syntax), Standard- und benannte Parameter verwendet (für optionale Argumente und lesbare Aufrufe) und Methodenüberladung anwendet (gleicher Name, unterschiedliche Parameter – für intuitive APIs, die verschiedene Argumenttypen behandeln), ist alltägliches Wissen.
Die Parametermodifizierer sind besonders wichtig zu verstehen: out wird häufig im allgegenwärtigen TryParse-Muster verwendet (int.TryParse(s, out var result) – sichere Rückgabe eines Erfolgssignals und eines Ergebnisses ohne Ausnahmen, ein häufiges, idiomatisches C#-Muster), ref ermöglicht es, die Variable des Aufrufers zu ändern, und in übergibt große Strukturen per Verweis zur Leistungsoptimierung.
Das Verständnis dieser Konzepte – Methoden, die Parameterfeatures (optional/benannt/params), Überladung für flexible APIs und die ref/out/in Modifizierer (besonders das out-basierte TryParse-Idiom) – ist grundlegend für das Schreiben von C#-Methoden und die Verwendung der vielen .NET-APIs, die auf diese Features angewiesen sind.
Da Methoden und ihre Parameter zentral für allen C#-Code sind und da Funktionen wie Überladung, optionale Parameter und das TryX-Muster ständig auftauchen, ist ihre Beherrschung essentiell und absolut notwendiges Wissen für eine effektive C#-Entwicklung.