Module C#.7 – Méthodes

Objectif

Maîtriser les méthodes C# : déclaration, paramètres (par défaut, nommés, variadiques), return, void, et overloading pour créer du code réutilisable et modulaire.

Théorie

Déclaration de méthode

Structure de base :

[modificateurs] typeRetour NomMethode([paramètres])
{
    // Code
    return valeur;  // Si typeRetour n'est pas void
}

Exemple simple :

public void Saluer()
{
    Console.WriteLine("Bonjour !");
}

Méthode avec paramètres :

public void Saluer(string nom)
{
    Console.WriteLine($"Bonjour {nom}");
}

Méthode avec retour :

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

Modificateurs

Visibilité :

• public : Accessible partout
• private : Accessible seulement dans la classe
• protected : Accessible dans la classe et enfants
• internal : Accessible dans le même assembly

Autres :

• static : Méthode de classe
• virtual : Peut être surchargée
• abstract : Pas d'implémentation (dans classe abstraite)
• override : Redéfinit une méthode parente

Paramètres

Paramètres par défaut

public void Afficher(string message, bool majuscules = false)
{
    if (majuscules)
    {
        Console.WriteLine(message.ToUpper());
    }
    else
    {
        Console.WriteLine(message);
    }
}

Afficher("Bonjour");           // Bonjour
Afficher("Bonjour", true);     // BONJOUR

Ordre important : Paramètres avec valeurs par défaut doivent être en dernier.

Paramètres nommés

Appeler les paramètres par nom (ordre n'importe plus).

public void CreerPersonne(string nom, int age, string ville = "Paris")
{
    Console.WriteLine($"{nom} a {age} ans, habite à {ville}");
}

CreerPersonne(nom: "Jean", age: 30);
CreerPersonne(age: 30, nom: "Jean");  // Ordre n'importe plus
CreerPersonne("Jean", 30, ville: "Lyon");

params (variadiques)

Accepte un nombre variable d'arguments.

public int Somme(params int[] nombres)
{
    return nombres.Sum();
}

Somme(1, 2, 3, 4, 5);  // 15

Important : params doit être le dernier paramètre.

ref et out

ref : Passe par référence (peut être modifié)

public void Modifier(ref int x)
{
    x = 10;  // Modifie la variable originale
}

int a = 5;
Modifier(ref a);
Console.WriteLine(a);  // 10

out : Passe par référence, doit être assigné

public void Diviser(int a, int b, out int resultat, out int reste)
{
    resultat = a / b;
    reste = a % b;
}

int res, rem;
Diviser(10, 3, out res, out rem);
Console.WriteLine($"Résultat : {res}, Reste : {rem}");

out variables (C# 7.0+) :

Diviser(10, 3, out int res, out int rem);
// Variables déclarées inline

Return

Retour simple :

public int Calculer()
{
    return 42;
}

Retour multiple (via objet ou tuple) :

// Avec classe
public class Resultat
{
    public int Valeur { get; set; }
    public string Message { get; set; }
}

public Resultat Calculer()
{
    return new Resultat { Valeur = 42, Message = "Succès" };
}

// Avec tuple (C# 7.0+)
public (int valeur, string message) Calculer()
{
    return (42, "Succès");
}

var (valeur, message) = Calculer();

Pas de return (void) :

public void Afficher()
{
    Console.WriteLine("Test");
    // Pas de return nécessaire
}

Return prématuré :

public int? Trouver(int[] nombres, int valeur)
{
    foreach (int n in nombres)
    {
        if (n == valeur)
        {
            return n;  // Sort immédiatement
        }
    }
    return null;  // Non trouvé
}

Overloading (Surcharge)

Plusieurs méthodes avec le même nom mais signatures différentes.

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

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

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

// Utilisation
Additionner(5, 3);        // Appelle la première
Additionner(5, 3, 2);     // Appelle la deuxième
Additionner(5.0, 3.0);    // Appelle la troisième

Règles :

• Nom identique
• Paramètres différents (nombre ou types)
• Type de retour peut être différent (mais pas seul critère)

Méthodes récursives

Une méthode qui s'appelle elle-même.

Exemple : Factorielle

public int Factorielle(int n)
{
    if (n <= 1)
    {
        return 1;
    }
    return n * Factorielle(n - 1);
}

Attention : Toujours avoir une condition d'arrêt.

Méthodes d'extension

Ajouter des méthodes à des types existants.

public static class StringExtensions
{
    public static string PremiereLettreMajuscule(this string str)
    {
        if (string.IsNullOrEmpty(str))
            return str;
        
        return char.ToUpper(str[0]) + str.Substring(1);
    }
}

// Utilisation
string nom = "jean";
string majuscule = nom.PremiereLettreMajuscule();  // "Jean"

Exercice

1. Méthodes de base

   • Créez des méthodes avec différents types de retour
   • Testez avec différents paramètres
   • Utilisez return

2. Paramètres

   • Créez des méthodes avec paramètres par défaut
   • Testez les paramètres nommés
   • Utilisez params pour variadiques

3. ref et out

   • Testez ref pour modifier des variables
   • Utilisez out pour retourner plusieurs valeurs
   • Comprenez les différences

4. Overloading

   • Créez plusieurs méthodes avec le même nom
   • Testez avec différents paramètres
   • Comprenez la résolution

5. Récursion

   • Créez des méthodes récursives
   • Testez avec différents cas
   • Faites attention aux conditions d'arrêt

Quiz

1. Que signifie static pour une méthode ?

   • Ne peut pas être modifiée
   • Appartient à la classe, pas à l'instance
   • Est plus rapide

2. Que sont les params ?

   • Paramètres optionnels
   • Paramètres variadiques (params int[])
   • Paramètres par défaut

3. Quelle est la différence entre ref et out ?

   • Aucune différence
   • out doit être assigné dans la méthode
   • ref est plus rapide

4. Qu'est-ce que l'overloading ?

   • Redéfinir une méthode
   • Plusieurs méthodes même nom, paramètres différents
   • Hériter d'une méthode

5. Que fait return dans une méthode void ?

   • Retourne null
   • Sort de la méthode (optionnel)
   • Erreur

Mini défi

Mission : Créer une bibliothèque de méthodes mathématiques

Créez une classe MathUtils avec des méthodes static :

Fonctions :

1. Opérations de base (additionner, multiplier avec params)
2. Calculs avancés (puissance, racine)
3. Statistiques (moyenne, max, min avec params)
4. Utilitaires (arrondir, formater)

Critères :

• ✅ Toutes les méthodes static
• ✅ Overloading approprié
• ✅ params où utile
• ✅ Gestion d'erreurs
• ✅ Documentation XML

Objectif : Maîtriser les méthodes, paramètres et overloading et créer une bibliothèque réutilisable.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez les méthodes, paramètres et overloading.