L'essentiel

À la leçon 7.1, chaque méthode faisait une tâche fermée : elle lisait ses propres données et affichait son propre résultat. C'est utile, mais limité. Une méthode AfficherLigne qui dessine toujours 20 signes = ne sert qu'à un seul endroit. Pour qu'une méthode soit réutilisable, il faut pouvoir lui donner des valeurs, et en recevoir un résultat.

Les paramètres : donner des valeurs

Un paramètre est une variable déclarée entre les parenthèses de la méthode. À l'appel, on fournit une valeur pour chacun : c'est l'argument.

AfficherLigne('=', 20);
Console.WriteLine("Journal de course");
AfficherLigne('-', 20);

static void AfficherLigne(char symbole, int longueur)
{
    for (int i = 0; i < longueur; i++)
    {
        Console.Write(symbole);
    }
    Console.WriteLine();
}

====================
Journal de course
--------------------

La même méthode dessine deux lignes différentes. Les arguments sont associés aux paramètres par leur position : le premier argument va dans le premier paramètre, et ainsi de suite. Leur nombre et leur type doivent correspondre.

La valeur de retour : récupérer un résultat

Une méthode qui calcule annonce le type de son résultat à la place de void, et le renvoie avec return. L'allure d'un coureur, en secondes par kilomètre, se calcule ainsi :

int allure = CalculerAllure(5, 1610);
Console.WriteLine($"Allure : {allure} s/km");
Console.WriteLine($"Au 10 km : {CalculerAllure(10, 3485)} s/km");

static int CalculerAllure(int km, int secondes)
{
    return secondes / km;
}

Un appel qui renvoie une valeur s'utilise partout où une valeur est permise : dans une affectation, dans un $"…", dans un calcul, dans une condition, et même comme argument d'un autre appel. Ici, la division entière est voulue : l'allure est arrondie à la seconde inférieure.

return termine la méthode immédiatement. Une méthode peut donc avoir plusieurs return, un par cas, pourvu que chaque chemin en rencontre un :

static string ObtenirNiveau(int allure)
{
    if (allure < 300)
    {
        return "rapide";
    }
    if (allure < 330)
    {
        return "modéré";
    }
    return "détente";
}

Pas besoin de else : si l'allure est inférieure à 300, le premier return a déjà quitté la méthode. Le dernier return couvre tous les autres cas ; sans lui, le compilateur refuse la méthode (CS0161, « les chemins du code ne retournent pas tous une valeur »).

Un tableau en paramètre

Un paramètre peut être un tableau. La méthode CalculerTotal ci-dessous additionne n'importe quel tableau d'entiers : on l'appelle une fois pour les distances et une fois pour les durées. Voici le journal complet, où chaque méthode est réutilisée :

const int Largeur = 44;
int[] distances = { 5, 10, 8, 21 };          // en km
int[] durees = { 1610, 3485, 2340, 7440 };   // en secondes

AfficherLigne('=', Largeur);
Console.WriteLine("Journal de course");
AfficherLigne('=', Largeur);

for (int i = 0; i < distances.Length; i++)
{
    int allure = CalculerAllure(distances[i], durees[i]);
    Console.WriteLine($"{distances[i]} km en {FormaterDuree(durees[i])} : {FormaterDuree(allure)}/km, {ObtenirNiveau(allure)}");
}

AfficherLigne('-', Largeur);
int kmTotal = CalculerTotal(distances);
int secondesTotal = CalculerTotal(durees);
Console.WriteLine($"Total : {kmTotal} km en {FormaterDuree(secondesTotal)}");
Console.WriteLine($"Allure moyenne : {FormaterDuree(CalculerAllure(kmTotal, secondesTotal))}/km");

// ---------- Méthodes ----------

static void AfficherLigne(char symbole, int longueur)
{
    for (int i = 0; i < longueur; i++)
    {
        Console.Write(symbole);
    }
    Console.WriteLine();
}

static int CalculerAllure(int km, int secondes)
{
    return secondes / km;
}

static string FormaterDuree(int secondes)
{
    int minutes = secondes / 60;
    int reste = secondes % 60;
    return $"{minutes} min {reste} s";
}

static string ObtenirNiveau(int allure)
{
    if (allure < 300)
    {
        return "rapide";
    }
    if (allure < 330)
    {
        return "modéré";
    }
    return "détente";
}

static int CalculerTotal(int[] valeurs)
{
    int total = 0;
    for (int i = 0; i < valeurs.Length; i++)
    {
        total += valeurs[i];
    }
    return total;
}

============================================
Journal de course
============================================
5 km en 26 min 50 s : 5 min 22 s/km, modéré
10 km en 58 min 5 s : 5 min 48 s/km, détente
8 km en 39 min 0 s : 4 min 52 s/km, rapide
21 km en 124 min 0 s : 5 min 54 s/km, détente
--------------------------------------------
Total : 44 km en 247 min 55 s
Allure moyenne : 5 min 38 s/km

Remarquez la répartition des rôles : les méthodes de calcul (CalculerAllure, CalculerTotal, FormaterDuree, ObtenirNiveau) n'affichent rien. Elles renvoient un résultat, et c'est le programme principal qui décide quoi en faire. C'est ce qui les rend réutilisables : FormaterDuree sert à la fois pour les durées, les allures et le total.

Un paramètre est une copie

int points = 10;
Doubler(points);
Console.WriteLine($"Après l'appel : {points}");

static void Doubler(int valeur)
{
    valeur = valeur * 2;
    Console.WriteLine($"Dans la méthode : {valeur}");
}

Dans la méthode : 20
Après l'appel : 10

La correction consiste à renvoyer le résultat et à le récupérer :

int points = 10;
points = Doubler(points);
Console.WriteLine($"Après l'appel : {points}");

static int Doubler(int valeur)
{
    return valeur * 2;
}

Passer par référence : ref et out

Il arrive qu'une méthode doive vraiment modifier la variable de l'appelant, ou renvoyer plus d'un résultat. C# offre pour cela le passage par référence : le paramètre n'est plus une copie, mais un autre nom pour la variable passée. Le mot ref s'écrit à la fois dans la déclaration et à l'appel.

int points = 10;
Doubler(ref points);
Console.WriteLine($"Après l'appel : {points}");

static void Doubler(ref int valeur)
{
    valeur = valeur * 2;
}

Après l'appel : 20

L'exemple classique est l'échange de la leçon 6.5, qui devient enfin une méthode réutilisable :

int a = 7;
int b = 3;
if (a > b)
{
    Echanger(ref a, ref b);
}
Console.WriteLine($"{a} {b}");

static void Echanger(ref int premier, ref int second)
{
    int temporaire = premier;
    premier = second;
    second = temporaire;
}

Le mot out sert à renvoyer des résultats supplémentaires. Un paramètre out n'a pas besoin de valeur à l'entrée, mais la méthode doit obligatoirement lui en donner une. À l'appel, on peut déclarer la variable sur place, avec out int :

ConvertirMinutes(135, out int heures, out int minutes);
Console.WriteLine($"135 min = {heures} h {minutes} min");

static void ConvertirMinutes(int total, out int heures, out int minutes)
{
    heures = total / 60;
    minutes = total % 60;
}

135 min = 2 h 15 min

Vous utilisez out depuis la leçon 3.3 sans le savoir : int.TryParse(texte, out valeur) renvoie un bool (la conversion a-t-elle réussi ?) et donne la valeur convertie par out. On peut écrire une méthode sur le même modèle :

Console.Write("Heure (0 à 23) : ");
if (EssayerLireHeure(Console.ReadLine() ?? "", out int heure))
{
    Console.WriteLine($"Rendez-vous à {heure} h.");
}
else
{
    Console.WriteLine("Heure invalide.");
}

// Même modèle que int.TryParse : un bool renvoyé, et la valeur par out
static bool EssayerLireHeure(string texte, out int heure)
{
    if (!int.TryParse(texte, out heure))
    {
        return false;
    }
    return heure >= 0 && heure <= 23;
}

Le paramètre par valeur reste la règle : en lisant Doubler(ref points), on voit que points peut changer, mais une méthode pleine de ref devient difficile à suivre. Réservez ref aux cas où la modification est le but même de la méthode, comme un échange.

Tester une méthode seule

Une méthode qui renvoie une valeur se teste facilement : on l'appelle avec des valeurs dont on connaît le résultat, et on compare. On choisit les valeurs comme pour un plan de tests : un cas normal, les cas limites, les valeurs extrêmes.

Il suffit d'écrire temporairement ces appels en haut du programme, dans des Console.WriteLine, puis de les retirer une fois la méthode validée. Dans Visual Studio, après un pas à pas sortant (Maj + F11), la fenêtre Automatique affiche aussi la valeur que la méthode vient de renvoyer.

Exercices

Console.WriteLine(Carre(4));
Console.WriteLine(Carre(2) + Carre(3));
int n = 5;
Augmenter(n);
Console.WriteLine(n);
Console.WriteLine(Resumer("Léa", 3));
Console.WriteLine(EstGrand(Carre(3)));

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

static void Augmenter(int x)
{
    x = x + 1;
}

static string Resumer(string nom, int nombre)
{
    return $"{nom} a {nombre} message(s)";
}

static bool EstGrand(int valeur)
{
    return valeur > 10;
}

int[] ventes = { 120, 80, 150, 95 };

int total = CalculerSomme(ventes);
AjouterPrime(total);
Console.WriteLine($"Total avec la prime : {total} $");
Console.WriteLine($"Moyenne par jour : {CalculerMoyenne(ventes):F2} $");
Console.WriteLine(DecrireTendance(ventes[0], ventes[ventes.Length - 1]));

static int CalculerSomme(int[] valeurs)
{
    int somme = 0;
    for (int i = 0; i < valeurs.Length; i++)
    {
        somme += valeurs[i];
    }
    return somme;
}

static void AjouterPrime(int montant)
{
    const int Prime = 50;
    montant = montant + Prime;
}

static double CalculerMoyenne(int[] valeurs)
{
    return CalculerSomme(valeurs) / valeurs.Length;
}

static string DecrireTendance(int fin, int debut)
{
    if (fin > debut)
    {
        return "Les ventes ont augmenté.";
    }
    if (fin < debut)
    {
        return "Les ventes ont baissé.";
    }
    return "Les ventes sont stables.";
}

Solutions

Console.WriteLine($"Aigles : {CalculerPoints(5, 2)} points");
Console.WriteLine($"Castors : {CalculerPoints(0, 0)} points");
Console.WriteLine($"Hiboux : {CalculerPoints(3, 4)} points");

static int CalculerPoints(int victoires, int nuls)
{
    const int PointsVictoire = 3;
    return victoires * PointsVictoire + nuls;
}

double[] notes = { 95, 90, 89.9, 72, 60, 59.9 };
foreach (double note in notes)
{
    Console.WriteLine($"{note} : {ObtenirMention(note)}");
}

static string ObtenirMention(double note)
{
    if (note >= 90)
    {
        return "Excellent";
    }
    if (note >= 80)
    {
        return "Très bien";
    }
    if (note >= 70)
    {
        return "Bien";
    }
    if (note >= 60)
    {
        return "Passable";
    }
    return "Échec";
}

95 : Excellent
90 : Excellent
89,9 : Très bien
72 : Bien
60 : Passable
59,9 : Échec

// Partie A : out
ConvertirSecondes(3725, out int h, out int m, out int s);
Console.WriteLine($"3725 s = {h} h {m} min {s} s");

// Partie B : ref
int a = 9;
int b = 2;
int c = 5;
TrierTrois(ref a, ref b, ref c);
Console.WriteLine($"{a} {b} {c}");

static void ConvertirSecondes(int total, out int heures, out int minutes, out int secondes)
{
    heures = total / 3600;
    minutes = total % 3600 / 60;
    secondes = total % 60;
}

static void TrierTrois(ref int a, ref int b, ref int c)
{
    if (a > b)
    {
        Echanger(ref a, ref b);
    }
    if (b > c)
    {
        Echanger(ref b, ref c);
    }
    if (a > b)
    {
        Echanger(ref a, ref b);
    }
}

static void Echanger(ref int premier, ref int second)
{
    int temporaire = premier;
    premier = second;
    second = temporaire;
}

int[] ventes = { 120, 80, 150, 95 };

int total = CalculerSomme(ventes);
total = AjouterPrime(total);
Console.WriteLine($"Total avec la prime : {total} $");
Console.WriteLine($"Moyenne par jour : {CalculerMoyenne(ventes):F2} $");
Console.WriteLine(DecrireTendance(ventes[0], ventes[ventes.Length - 1]));

static int CalculerSomme(int[] valeurs)
{
    int somme = 0;
    for (int i = 0; i < valeurs.Length; i++)
    {
        somme += valeurs[i];
    }
    return somme;
}

static int AjouterPrime(int montant)
{
    const int Prime = 50;
    return montant + Prime;
}

static double CalculerMoyenne(int[] valeurs)
{
    double somme = CalculerSomme(valeurs);
    return somme / valeurs.Length;
}

static string DecrireTendance(int debut, int fin)
{
    if (fin > debut)
    {
        return "Les ventes ont augmenté.";
    }
    if (fin < debut)
    {
        return "Les ventes ont baissé.";
    }
    return "Les ventes sont stables.";
}

Console.WriteLine(EstBissextile(2024));
Console.WriteLine(EstBissextile(1900));
Console.WriteLine(JoursDansMois(2, 2024));
Console.WriteLine(JoursDansMois(2, 2025));
Console.WriteLine(JourDeLAnnee(1, 1, 2025));
Console.WriteLine(JourDeLAnnee(1, 3, 2024));
Console.WriteLine(JourDeLAnnee(1, 3, 2025));
Console.WriteLine(JourDeLAnnee(31, 12, 2024));
Console.WriteLine(JourDeLAnnee(24, 6, 2026));

static bool EstBissextile(int annee)
{
    return (annee % 4 == 0 && annee % 100 != 0) || annee % 400 == 0;
}

static int JoursDansMois(int mois, int annee)
{
    int[] joursParMois = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    if (mois == 2 && EstBissextile(annee))
    {
        return 29;
    }
    return joursParMois[mois - 1];
}

static int JourDeLAnnee(int jour, int mois, int annee)
{
    int rang = jour;
    for (int m = 1; m < mois; m++)
    {
        rang += JoursDansMois(m, annee);
    }
    return rang;
}

Je fais le point

• Je sais déclarer des paramètres et passer les arguments dans le bon ordre.
• Je sais renvoyer un résultat avec return et l'utiliser dans une affectation, un affichage ou une condition.
• Je choisis le type de retour : void, int, double, string ou bool.
• Je sais qu'un paramètre est une copie et qu'il faut renvoyer un résultat pour changer une variable.
• Je sais passer un tableau en paramètre.
• Je sais utiliser ref pour modifier une variable de l'appelant et out pour renvoyer plusieurs résultats.
• Je teste une méthode seule avec des valeurs connues, y compris les cas limites.