Méthodes C# : paramètres, retours et surcharges

Une méthode donne un nom à un traitement réutilisable. Elle limite la duplication, découpe un problème en étapes et permet de tester chaque comportement séparément.

Anatomie d’une méthode

static int Additionner(int a, int b)
{
    return a + b;
}

• static indique ici que la méthode peut être appelée sans créer d’objet ;
• int est le type de la valeur retournée ;
• Additionner est le nom de la méthode ;
• a et b sont ses paramètres.

L’appel fournit des arguments :

int total = Additionner(10, 15);

Un paramètre figure dans la déclaration ; un argument est la valeur passée lors de l’appel.

Retourner une valeur ou utiliser void

static int Carre(int nombre)
{
    return nombre * nombre;
}

static void Afficher(int nombre)
{
    Console.WriteLine($"Résultat : {nombre}");
}

Une méthode non void doit retourner une valeur compatible sur tous les chemins d’exécution. Une méthode void réalise une action sans produire de résultat exploitable par l’appelant.

Écrire une méthode courte

Une méthode réduite à une expression peut employer => :

static int Carre(int nombre) => nombre * nombre;

Cette syntaxe est utile si elle reste immédiatement lisible.

Surcharger une méthode

La surcharge permet plusieurs signatures sous le même nom :

static int Additionner(int a, int b) => a + b;
static double Additionner(double a, double b) => a + b;
static int Additionner(int a, int b, int c) => a + b + c;

Le compilateur choisit la surcharge d’après le nombre et le type des arguments. Le type de retour seul ne suffit pas à différencier deux méthodes.

Paramètres optionnels et nommés

static void AfficherProfil(
    string nom,
    int age = 0,
    string ville = "Inconnue")
{
    Console.WriteLine($"{nom}, {age} ans, {ville}");
}

AfficherProfil("Alice");
AfficherProfil("Bob", 25);
AfficherProfil(nom: "Charlie", ville: "Lyon");

Les paramètres obligatoires précèdent les paramètres optionnels. Les arguments nommés rendent un appel plus explicite et permettent d’omettre une valeur optionnelle intermédiaire.

Décomposer un petit programme

int nombre = LireEntier();
int carre = Carre(nombre);
Afficher(carre);

static int LireEntier()
{
    Console.Write("Entrez un entier : ");
    int valeur;

    while (!int.TryParse(Console.ReadLine(), out valeur))
    {
        Console.Write("Saisie invalide, recommencez : ");
    }

    return valeur;
}

static int Carre(int nombre) => nombre * nombre;

static void Afficher(int resultat) =>
    Console.WriteLine($"Carré : {resultat}");

valeur est déclarée avant la boucle : une variable out int valeur déclarée dans la condition d’un while n’existerait plus après la boucle.

Chaque méthode a une responsabilité : lire, calculer ou afficher. Cette séparation prépare naturellement l’étude des classes et des objets.

Retourner plusieurs valeurs

Une méthode ne retourne qu’une valeur, mais cette valeur peut être un tuple nommé. C’est souvent plus lisible que plusieurs paramètres out :

var (min, max, moyenne) = Statistiques([12.5m, 18m, 9.75m]);
Console.WriteLine($"Min {min}, max {max}, moyenne {moyenne:N2}");

static (decimal Min, decimal Max, decimal Moyenne) Statistiques(IReadOnlyList<decimal> valeurs)
{
    if (valeurs.Count == 0)
    {
        throw new ArgumentException("La liste ne peut pas être vide.", nameof(valeurs));
    }

    return (valeurs.Min(), valeurs.Max(), valeurs.Average());
}

La méthode vérifie ses arguments dès l’entrée : une précondition violée lève une exception claire plutôt qu’un résultat absurde plus loin. Le paramètre IReadOnlyList<decimal> indique aussi à l’appelant que la méthode ne modifiera pas sa liste.

Exercice : méthode de validation réutilisable

Écrivez une méthode LireEntierDansIntervalle(string message, int min, int max) qui redemande la saisie jusqu’à obtenir un entier compris entre min et max, puis utilisez-la pour lire un mois (1 à 12) et un jour (1 à 31).

int mois = LireEntierDansIntervalle("Mois (1-12) : ", 1, 12);
int jour = LireEntierDansIntervalle("Jour (1-31) : ", 1, 31);
Console.WriteLine($"Date saisie : {jour:00}/{mois:00}");

static int LireEntierDansIntervalle(string message, int min, int max)
{
    while (true)
    {
        Console.Write(message);
        string saisie = Console.ReadLine()
            ?? throw new InvalidOperationException("Entrée standard fermée.");

        if (int.TryParse(saisie, out int valeur) && valeur >= min && valeur <= max)
        {
            return valeur;
        }

        Console.WriteLine($"Entrez un entier entre {min} et {max}.");
    }
}

Erreurs fréquentes

• oublier return dans une méthode non void ;
• créer une méthode très longue qui réalise plusieurs tâches ;
• tenter une surcharge fondée uniquement sur le type de retour ;
• placer un paramètre obligatoire après un paramètre optionnel ;
• modifier un paramètre en pensant modifier automatiquement la variable de l’appelant.

Épisode précédent : tableaux, listes et dictionnaires. La suite abordera les classes et la programmation orientée objet.

La série C# pour débutants

Cette série suit une progression : chaque épisode réutilise les notions des précédents.

1. Variables et types
2. Saisie utilisateur et TryParse
3. Conditions if, else et ternaire
4. Switch et pattern matching
5. Boucles for, while et foreach
6. Tableaux, listes, dictionnaires et LINQ
7. Méthodes, paramètres et surcharges (vous êtes ici)

Une fois ces bases acquises, le parcours C# et ASP.NET Core prolonge la série vers les API web, la validation et l’asynchrone.