Standardwerte und benannte Argumente

1. Standardwerte für Parameter

Stell dir ein Café vor: Wenn du nicht sagst, ob du Zucker im Kaffee willst, packt der Barista standardmäßig einen Löffel rein. Aber manchmal willst du… zwei! Oder gar keinen Zucker (Respekt!). Genau so ist es bei Methoden: Es ist oft praktisch, wenn manche Parameter Standardwerte bekommen, falls du sie nicht explizit angibst.

Und benannte Argumente sind wie die Möglichkeit, beim Kaffee zu sagen: „Und die Milch bitte soja und nicht normal“, egal in welcher Reihenfolge die Zutaten sonst kommen.

In C# machen beide Mechanismen deinen Code sauberer, bequemer und schützen vor Fehlern. Sie sind in echten Projekten ständig zu finden: von .NET-Bibliotheken bis zu beliebten Frameworks – deshalb sehen Arbeitgeber gern, dass du damit umgehen kannst.

Syntax

Ein Standardwert für einen Funktionsparameter wird direkt in der Methodendeklaration mit dem Zeichen = gesetzt. Wenn du beim Methodenaufruf diesen Parameter nicht angibst, wird der Standardwert verwendet.

void PrintStudent(string name, int age = 18)
{
    Console.WriteLine($"Student: {name}, Alter: {age}");
}

Wie funktioniert das?

• Wenn du PrintStudent("Alice"); aufrufst, wird ausgegeben: Student: Alice, Alter: 18.
• Wenn du PrintStudent("Alex", 22); aufrufst, wird ausgegeben: Student: Alex, Alter: 22.

Funktioniert das für alle Typen?

Einen Standardwert kannst du für jeden Parametertyp setzen, aber es gibt Besonderheiten:

• Für Referenztypen (string, Klassen usw.): Standardmäßig kannst du null oder einen bestimmten Literal angeben.
• Für Werttypen (int, double, bool usw.): Gib einfach einen Literal des passenden Typs an.
• Für Enums (enum), Strukturen: Auch hier kannst du Standardwerte nutzen.

void AddStudent(string name, int course = 1, double averageScore = 5.0, string comment = null)
{
    Console.WriteLine($"Student hinzugefügt: {name}, Kurs: {course}, Durchschnittsnote: {averageScore}, Kommentar: {comment}");
}

Aufrufe:

• AddStudent("Johann");
• AddStudent("Maria", 2);
• AddStudent("Teodor", 2, 4.7, "Mit Auszeichnung");

Reihenfolge der Parameter mit Werten

Alle optionalen Parameter (mit Standardwert) müssen rechts stehen (nach allen Pflichtparametern). Wenn du einen Parameter mit Standardwert vor einen Pflichtparameter stellst, knallt dir der Compiler die Tür vor der Nase zu.

// Fehler!
void Test(int a = 1, int b)
{
    // ...
}

Warum? Weil der Compiler sonst nicht weiß, welches Argument zu welchem Parameter gehört, wenn du die Methode aufrufst.

2. Benannte Argumente

Standardmäßig musst du beim Methodenaufruf die Argumente in genau der Reihenfolge angeben, wie die Parameter in der Methodendefinition stehen. Aber manchmal ist die Liste lang, manche Parameter haben Standardwerte, und man vertut sich schnell.

Benannte Argumente erlauben dir, explizit anzugeben, welchem Parameter du welches Argument gibst – in beliebiger Reihenfolge.

AddStudent(name: "Elizabeth", averageScore: 4.2, comment: "Bester Student des Semesters");

• Hier geben wir den Kurs (course) nicht an, also ist er 1 (Standardwert).
• Du musst dir nicht merken, an welcher Stelle der Parameter comment steht – einfach den Namen angeben.

Du kannst die Parameter sogar vertauschen:

AddStudent(averageScore: 3.7, name: "George");

Das ist super praktisch und macht den Code viel lesbarer!

Verwendung mit Positionsargumenten

Benannte und Positionsargumente (ohne Namen) kannst du mischen, aber alle Positionsargumente müssen vor den benannten stehen.

// Korrekt
AddStudent("Sunny", averageScore: 4.9);

// Fehler
AddStudent(course: 2, "Philip");

Nach dem ersten benannten Parameter muss alles weitere auch benannt sein. Der Compiler achtet streng auf diese Reihenfolge, damit du keine bösen Überraschungen erlebst.

Praktisch bei Methoden mit vielen Parametern

Das ist ein beliebter Trick bei Methoden mit vielen Zusatzoptionen. Zum Beispiel, wenn du eine Funktion schreibst, um einen User irgendwo in einer Cloud-Datenbank anzulegen:

void RegisterUser(
    string username,
    string password,
    string email = null,
    bool admin = false,
    bool sendWelcomeEmail = true,
    string language = "ru"
)

Ohne benannte Argumente sieht der Aufruf gruselig aus:

RegisterUser("cat", "qwerty", null, false, true, "ru");

Mit benannten Argumenten ist alles lesbar und sicher:

RegisterUser("cat", "qwerty", admin: true, sendWelcomeEmail: false, language: "en");

Tipp: Nutze benannte Argumente, damit dein Code auch ohne Doku verständlich bleibt!

3. Besonderheiten und typische Fehler

Gerade am Anfang, wenn du Standardwerte und benannte Argumente nutzt, kann man an mehreren Stellen danebenliegen.

• Reihenfolge der Parameter. Setze Parameter mit Standardwerten immer nach den Pflichtparametern. Wenn du sie vertauschst, gibt's einen Compilerfehler.
• Standardwert in einer Bibliothek ändern. Wenn du den Standardwert in einer Bibliothek änderst, nutzen alte Clients nicht automatisch den neuen Wert. Der Standardwert wird in den aufrufenden Code kompiliert. Also überleg dir gut, ob du Standardwerte in öffentlichen Bibliotheken änderst.
• Mischen von Positions- und benannten Argumenten. Wenn du Positions- und benannte Argumente mischst, aber nach einem benannten wieder ein Positionsargument angibst – das klappt nicht. Zum Beispiel: Func(a: 1, 2) – gibt einen Fehler.
• Tippfehler im Parameternamen. Der Compiler ist hier streng: Wenn du dich vertippst (z.B. naem: "Michael" schreibst), bekommst du eine Fehlermeldung wie: "Kein solcher Parameter, was machst du da überhaupt?!"