Aller au contenu principal

Méthodes

Notions théoriques​

Déclarer et appeler une méthode​

En C# avec les top-level statements, les méthodes se déclarent avec le mot-clé static en dehors du code principal :

// Appel de la méthode
Bonjour("Alice");
Bonjour("Bob");

// Déclaration de la méthode (peut être après l'appel)
static void Bonjour(string prenom)
{
    Console.WriteLine($"Bonjour, {prenom} !");
}

Méthodes avec valeur de retour​

double resultat = Additionner(3.5, 2.1);
Console.WriteLine(resultat);   // 5.6

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

static string ObtenirMention(double note)
{
    return note switch
    {
        >= 16 => "Très bien",
        >= 14 => "Bien",
        >= 10 => "Passable",
        _     => "Insuffisant",
    };
}

Paramètres optionnels et valeurs par défaut​

// Le paramètre 'majuscules' est optionnel (valeur par défaut : false)
static void AfficherNom(string nom, bool majuscules = false)
{
    string affichage = majuscules ? nom.ToUpper() : nom;
    Console.WriteLine(affichage);
}

AfficherNom("Alice");           // Alice
AfficherNom("Bob", true);       // BOB

Paramètres nommés​

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

// Appel avec paramètres nommés (l'ordre n'importe plus)
CreerCompte(age: 20, nom: "Alice", ville: "Lyon");

Surcharge (overloading)​

// Même nom, signatures différentes
static void Afficher(string texte)
{
    Console.WriteLine(texte);
}

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

static void Afficher(string texte, int fois)
{
    for (int i = 0; i < fois; i++)
        Console.WriteLine(texte);
}

Portée des variables​

Une variable déclarée dans une méthode est locale à cette méthode :

static void MaMethode()
{
    int x = 10;   // locale à MaMethode
}

// Console.WriteLine(x);   // ERREUR : x n'existe pas ici

Expression-bodied methods (méthodes en une ligne)​

// Syntaxe classique
static double Carre(double x)
{
    return x * x;
}

// Syntaxe expression-bodied (équivalent)
static double Carre(double x) => x * x;

static string Bonjour(string prenom) => $"Bonjour, {prenom} !";

Commentaires XML de documentation​

/// <summary>
/// Calcule la moyenne d'un tableau de notes.
/// </summary>
/// <param name="notes">Tableau de notes entre 0 et 20.</param>
/// <returns>La moyenne arrondie à 2 décimales.</returns>
static double CalculerMoyenne(double[] notes)
{
    if (notes.Length == 0) return 0;
    return notes.Sum() / notes.Length;
}

Exemple pratique​

// Programme principal
double[] notes = { 14.5, 12.0, 17.5, 9.0, 15.0 };

Console.WriteLine("=== Bulletin de notes ===");
for (int i = 0; i < notes.Length; i++)
{
    Console.WriteLine($"  Note {i + 1} : {notes[i]:F1} — {ObtenirMention(notes[i])}");
}

double moyenne = CalculerMoyenne(notes);
Console.WriteLine(new string('-', 30));
Console.WriteLine($"  Moyenne : {moyenne:F2} /20 — {ObtenirMention(moyenne)}");
AfficherBulletin("Alice Dupont", moyenne);

// Méthodes
static double CalculerMoyenne(double[] notes)
{
    if (notes.Length == 0) return 0;
    double somme = 0;
    foreach (double n in notes) somme += n;
    return somme / notes.Length;
}

static string ObtenirMention(double note) => note switch
{
    >= 16 => "Très bien",
    >= 14 => "Bien",
    >= 12 => "Assez bien",
    >= 10 => "Passable",
    _     => "Insuffisant",
};

static void AfficherBulletin(string eleve, double moyenne)
{
    Console.WriteLine($"\nÉlève : {eleve}");
    Console.WriteLine($"Résultat : {(moyenne >= 10 ? "ADMIS" : "REFUSÉ")}");
}

Test de mémorisation/compréhension​


Pourquoi les méthodes déclarées avec les top-level statements doivent-elles avoir le mot-clé `static` ?


Quelle est la syntaxe d'une méthode expression-bodied en C# ?


Comment déclare-t-on un paramètre optionnel en C# ?


Qu'est-ce que la surcharge de méthodes (overloading) ?


Quelle est la portée d'une variable déclarée à l'intérieur d'une méthode ?


TP pour réfléchir et résoudre des problèmes​

Vous allez créer un système de notation avec plusieurs méthodes.

Étape 1 — Méthode CalculerMoyenne​

Créez la méthode CalculerMoyenne qui prend un tableau de doubles et retourne leur moyenne.


Bonne pratique - Gérer le cas vide

Toujours vérifier les cas limites en début de méthode (if (notes.Length == 0) return 0). Diviser par zéro provoque une exception en C# pour les entiers (DivideByZeroException) et retourne NaN pour les doubles. Mieux vaut retourner une valeur explicite.

Étape 2 — Méthode ObtenirMention expression-bodied​

Créez la méthode ObtenirMention en syntaxe expression-bodied.


Bonne pratique - Expression-bodied pour les méthodes simples

Utilisez la syntaxe => pour les méthodes dont le corps tient en une expression. Cela rend le code plus concis et lisible. Pour les méthodes plus complexes (plusieurs instructions, boucles, conditions multiples), gardez les accolades classiques.

Étape 3 — Méthode AfficherBulletin​

Créez la méthode AfficherBulletin qui affiche le résultat complet.


Bonne pratique - Décomposer en méthodes spécialisées

AfficherBulletin appelle CalculerMoyenne et ObtenirMention : chaque méthode a une seule responsabilité. Si la formule de calcul change, vous ne modifiez que CalculerMoyenne sans toucher à l'affichage. C'est le principe de séparation des responsabilités.

📌 Une solution