Les méthodes sont des fonctions définies dans une classe. C# prend en charge des fonctionnalités de paramètres riches — arguments optionnels/nommés, modificateurs ref/out/in, tableaux — et (plusieurs méthodes avec le même nom mais des paramètres différents).
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
Les méthodes spécifient un type de retour, un nom et des paramètres. Les paramètres par défaut rendent les arguments optionnels, et les arguments nommés vous permettent de passer par nom (plus clair, peuvent ignorer les optionnels).
// 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 est largement utilisé dans le modèle TryParse (retournant un indicateur de succès plus le résultat en toute sécurité) ; ref permet de modifier la variable de l'appelant ; in transmet efficacement les grandes structures sans copie.
// 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
La surcharge permet à plusieurs méthodes de partager un nom, distinguées par les types/nombre de paramètres — le compilateur sélectionne celle qui correspond. params accepte un nombre variable d'arguments.
Les méthodes sont les éléments constitutifs du comportement en C#, et comprendre leurs fonctionnalités de paramètres riches est important pour écrire du code flexible et expressif.
Savoir comment définir des méthodes (y compris la syntaxe concise à corps d'expression), utiliser les paramètres par défaut et nommés (pour les arguments optionnels et les appels lisibles), et appliquer la surcharge de méthode (même nom, paramètres différents — pour des API intuitives qui gèrent différents types d'arguments) est une connaissance quotidienne.
Les modificateurs de paramètres sont particulièrement importants à comprendre : out est largement utilisé dans l'omniprésent modèle TryParse (int.TryParse(s, out var result) — retournant en toute sécurité un indicateur de succès et un résultat sans exceptions, un modèle courant et idiomatique en C#), ref permet de modifier la variable de l'appelant, et in transmet les grandes structures par référence pour les performances.
Comprendre ces éléments — les méthodes, les fonctionnalités de paramètres (optionnels/nommés/params), la surcharge pour les API flexibles, et les modificateurs ref/out/in (en particulier l'idiome TryParse basé sur out) — est fondamental pour écrire des méthodes C# et pour utiliser les nombreuses API .NET qui reposent sur ces fonctionnalités.
Puisque les méthodes et leurs paramètres sont au cœur de tout code C#, et puisque des fonctionnalités comme la surcharge, les paramètres optionnels et le modèle TryX apparaissent constamment, les maîtriser est une connaissance essentielle et incontournable pour un développement C# efficace.