Méthodes et utilisation des paramètres en C#

En C#, les méthodes sont utilisées pour organiser et réutiliser du code répétitif. Une méthode exécute une tâche spécifique et peut être appelée plusieurs fois dans un programme. Cela permet d’éviter la duplication de code et améliore la lisibilité.

Définir et appeler des méthodes

Une méthode est définie avec un type de retour, un nom et des paramètres optionnels. Par exemple, la méthode suivante affiche un simple message :

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

static void Main()
{
    Saluer(); // appel de méthode
}

// Résultat :
Bonjour!

Méthodes avec paramètres

Les méthodes peuvent recevoir des valeurs externes. Ces valeurs sont appelées paramètres. Dans l’exemple suivant, un paramètre « nom » est transmis et le message de salutation est personnalisé :

static void Saluer(string nom)
{
    Console.WriteLine("Bonjour " + nom + "!");
}

static void Main()
{
    Saluer("Alice");
    Saluer("Marc");
}

// Résultat :
Bonjour Alice!
Bonjour Marc!

Méthodes avec valeur de retour

Les méthodes peuvent effectuer une opération et renvoyer un résultat. Pour cela, un type de retour est défini (int, string, etc.). L’exemple suivant montre une méthode qui additionne deux nombres :

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

static void Main()
{
    int resultat = Additionner(5, 7);
    Console.WriteLine("Somme : " + resultat);
}

// Résultat :
Somme : 12

Paramètres par défaut

Les paramètres peuvent avoir des valeurs par défaut. Si aucun argument n’est fourni lors de l’appel, cette valeur est utilisée :

static void AfficherMessage(string texte = "Message par défaut")
{
    Console.WriteLine(texte);
}

static void Main()
{
    AfficherMessage("Bonjour le monde!");
    AfficherMessage();
}

// Résultat :
Bonjour le monde!
Message par défaut

Paramètre vs Argument

Un paramètre est le nom utilisé dans la définition de la méthode. Un argument est la valeur réelle transmise lors de l’appel.

static void Carre(int nombre) // paramètre : nombre
{
    Console.WriteLine(nombre * nombre);
}

static void Main()
{
    Carre(4); // argument : 4
}

// Résultat :
16

Surcharge (Overloading)

On peut définir plusieurs méthodes avec le même nom mais un nombre ou un type de paramètres différent. C’est ce qu’on appelle la surcharge de méthode :

static int Multiplier(int a, int b)
{
    return a * b;
}

static int Multiplier(int a, int b, int c)
{
    return a * b * c;
}

static void Main()
{
    Console.WriteLine(Multiplier(3, 4));
    Console.WriteLine(Multiplier(2, 3, 4));
}

// Résultat :
12
24

Récursivité

Lorsqu’une méthode s’appelle elle-même, on parle de récursivité. Chaque récursivité doit avoir une condition d’arrêt, sinon la boucle se poursuivra indéfiniment.

static int Factorielle(int n)
{
    if (n <= 1)
        return 1; // condition d’arrêt
    return n * Factorielle(n - 1); // appel récursif
}

static void Main()
{
    Console.WriteLine(Factorielle(5)); // 120
}

Paramètres ref et out

En C#, les mots-clés ref et out permettent de passer des paramètres par référence. Ainsi, les modifications effectuées dans la méthode sont visibles à l’extérieur.

// Exemple ref
static void Incrementer(ref int nombre)
{
    nombre++;
}

// Exemple out
static void Lire(out int resultat)
{
    resultat = 42;
}

static void Main()
{
    int x = 5;
    Incrementer(ref x);
    Console.WriteLine(x); // 6

    int y;
    Lire(out y);
    Console.WriteLine(y); // 42
}

Paramètres multiples avec params

Le mot-clé params permet à une méthode d’accepter un nombre variable de paramètres. On peut transmettre un tableau ou des valeurs individuelles.

Exemple : Additionner des nombres

static int Additionner(params int[] nombres)
{
    int somme = 0;
    foreach (int n in nombres)
        somme += n;
    return somme;
}

static void Main()
{
    Console.WriteLine(Additionner(1, 2, 3));       // 6
    Console.WriteLine(Additionner(5, 10, 15, 20)); // 50
}

Exemple : Concaténer des mots

static string Concatener(params string[] mots)
{
    return string.Join(" ", mots);
}

static void Main()
{
    Console.WriteLine(Concatener("C#", "est", "un", "langage", "puissant."));
    // Résultat : C# est un langage puissant.
}

Fonctions locales

Depuis C# 7.0, il est possible de définir des méthodes à l’intérieur d’une autre méthode. On les appelle fonctions locales. Elles permettent d’écrire un code plus clair et mieux structuré.

static void Main()
{
    int Multiplier(int a, int b) // fonction locale
    {
        return a * b;
    }

    Console.WriteLine(Multiplier(3, 4)); // 12
}

TL;DR