1. Valeurs par défaut pour les paramètres
Imagine un coffee shop : si tu ne précises pas si tu veux du sucre dans ton café, le barista va par défaut mettre une cuillère. Mais parfois tu voudras… deux ! Ou carrément sans sucre (héroïsme !). Pareil avec les méthodes : c’est pratique que certains paramètres prennent une valeur standard si tu ne les précises pas.
Et les arguments nommés, c’est comme pouvoir dire dans ta commande de café : « Et le lait, je le veux soja, pas normal », peu importe dans quel ordre les ingrédients sont servis d’habitude.
En C#, ces deux trucs rendent ton code plus clean, plus pratique et t’évitent des bugs. On les croise tout le temps dans les vrais projets : des libs .NET aux frameworks populaires — du coup les employeurs kiffent voir que tu maîtrises ça.
Syntaxe
La valeur par défaut d’un paramètre de fonction se met direct dans la déclaration de la méthode avec le signe =. Si tu n’indiques pas ce paramètre à l’appel, c’est la valeur par défaut qui sera utilisée.
void PrintStudent(string name, int age = 18)
{
Console.WriteLine($"Étudiant : {name}, âge : {age}");
}
Comment ça marche ?
- Si tu appelles PrintStudent("Alice"); — ça affiche : Étudiant : Alice, âge : 18.
- Si tu appelles PrintStudent("Sacha", 22); — ça affiche : Étudiant : Sacha, âge : 22.
Ça marche pour tous les types ?
Tu peux mettre une valeur par défaut pour n’importe quel type de paramètre, mais y’a des subtilités :
- Pour les types référence (string, classes, etc.) : tu peux mettre null ou une valeur littérale.
- Pour les types valeur (int, double, bool, etc.) : tu mets un littéral du type voulu.
- Pour les énumérations (enum), structs : tu peux aussi utiliser des valeurs par défaut.
void AddStudent(string name, int course = 1, double averageScore = 5.0, string comment = null)
{
Console.WriteLine($"Étudiant ajouté : {name}, année : {course}, moyenne : {averageScore}, commentaire : {comment}");
}
Appels :
- AddStudent("Ivan");
- AddStudent("Maria", 2);
- AddStudent("Fiodor", 2, 4.7, "Avec mention");
Ordre des paramètres avec valeurs
Tous les paramètres optionnels (avec valeur par défaut) doivent être à droite (après tous les obligatoires). Si tu tentes de mettre un paramètre avec valeur par défaut avant un obligatoire, le compilateur va râler sévère.
// Erreur !
void Test(int a = 1, int b)
{
// ...
}
Pourquoi ? Sinon le compilateur ne saura pas à quel paramètre correspond chaque argument à l’appel de la méthode.
2. Arguments nommés
Par défaut, quand tu appelles une méthode et que tu passes des arguments, leur ordre doit coller à celui des paramètres dans la définition. Mais parfois la liste est longue, certains paramètres ont des valeurs par défaut, et tu peux vite te planter.
Les arguments nommés te permettent de dire explicitement à quel paramètre tu passes quel argument, dans n’importe quel ordre.
AddStudent(name: "Élisabeth", averageScore: 4.2, comment: "Meilleur étudiant du semestre");
- Ici on ne précise pas l’année (course), donc ce sera 1 (par défaut).
- Pas besoin de se souvenir de la position du paramètre comment — tu mets juste son nom.
Tu peux même inverser l’ordre des paramètres :
AddStudent(averageScore: 3.7, name: "Georges");
C’est super pratique, et le code devient bien plus lisible !
Utilisation avec des arguments positionnels
Tu peux mélanger arguments nommés et positionnels (sans nom), mais tous les positionnels doivent être avant les nommés.
// OK
AddStudent("Serge", averageScore: 4.9);
// Erreur
AddStudent(course: 2, "Philippe");
Après le premier argument nommé, tout le reste doit être nommé aussi. Le compilateur surveille ça de près pour t’éviter des surprises.
Pratique avec des méthodes à plein de paramètres
C’est super courant quand tu utilises des méthodes avec plein d’options. Par exemple, si tu écrivais une fonction pour ajouter un utilisateur dans une base cloud :
void RegisterUser(
string username,
string password,
string email = null,
bool admin = false,
bool sendWelcomeEmail = true,
string language = "ru"
)
Un appel sans arguments nommés ferait peur :
RegisterUser("cat", "qwerty", null, false, true, "ru");
Avec des arguments nommés, tout est lisible et safe :
RegisterUser("cat", "qwerty", admin: true, sendWelcomeEmail: false, language: "en");
Astuce : utilise les arguments nommés pour que ton code soit compréhensible même sans doc !
3. Particularités d’implémentation et erreurs fréquentes
Quand tu commences à utiliser les valeurs par défaut et les arguments nommés, tu peux te planter à plusieurs endroits.
- Ordre des paramètres. Mets toujours les paramètres avec valeurs par défaut après les obligatoires. Si tu inverses, le compilateur va gueuler.
- Changer la valeur par défaut dans une lib. Si tu modifies la valeur par défaut dans une lib, les anciens clients ne vont pas l’utiliser automatiquement. La valeur par défaut est compilée dans le code appelant. Donc réfléchis avant de changer les valeurs par défaut dans les libs publiques.
- Mélange d’arguments positionnels et nommés. Si tu mélanges les deux, mais qu’après un nommé tu remets un positionnel — ça marche pas. Par exemple : Func(a: 1, 2) — ça va planter.
- Fautes de frappe dans le nom du paramètre. Le compilateur est strict : si tu te trompes (genre tu écris naem: "Micha"), tu auras une erreur du genre : "Aucun paramètre de ce nom, tu fais quoi là ?!".
GO TO FULL VERSION