1. Fonctions/Méthodes en C#
Tu as déjà appris pas mal de commandes en C#, donc tu peux écrire des programmes assez complexes. 10, 20, 30 lignes de code dans un programme — c’est pas si énorme, non ?
Mais un programme de 100+ lignes, là ça commence à devenir gros, et c’est pas évident de s’y retrouver. Est-ce qu’on peut rendre l’écriture et la lecture de programmes longs plus simple ?
Oui, et pour ça, on a les méthodes (fonctions).
C’est quoi une méthode ? Pour faire simple, une méthode, c’est un groupe de commandes qui a un nom unique. En gros, on regroupe plusieurs commandes sous un même nom. Et voilà, t’as une méthode.
Imaginons que t’as du code pour dessiner un chat :
Console.WriteLine(" |\\__/,| (`\\");
Console.WriteLine(" |o_o |__ _) )");
Console.WriteLine(" (____/ (_/ ");
Voilà ce que ça affiche :
|\__/,| (`\
|o_o |__ _) )
(____/ (_/
Tu peux juste mettre ce code dans une méthode à part et dessiner autant de chats que tu veux :
void WriteCat()
{
Console.WriteLine(" |\\__/,| (`\\");
Console.WriteLine(" |o_o |__ _) )");
Console.WriteLine(" (____/ (_/ ");
}
//on dessine trois chats
WriteCat();
WriteCat();
WriteCat();
Quand le programme tourne, à chaque fois que tu fais WriteCat(), il exécute toutes les commandes à l’intérieur de la méthode WriteCat(). On a juste créé une nouvelle commande (méthode) en regroupant plusieurs commandes.
À quoi servent les fonctions :
- Découpent le programme en parties, chacune fait son job.
- Facilitent la réutilisation : tu l’écris une fois, tu l’utilises autant de fois que tu veux.
- Réduisent les bugs : tu corriges la fonction à un seul endroit.
- Donnent des "noms" aux actions compliquées — ça rend le code beaucoup plus lisible.
Termes : fonction, méthode, procédure
En C#, les mots fonction et méthode veulent généralement dire la même chose, mais y’a quelques nuances.
- Méthode — fonction qui appartient à une classe ou un objet (en C#, presque tout est une méthode).
- Procédure — fonction qui ne renvoie rien (void-méthodes).
- Fonction — au sens large, toute partie nommée du programme qu’on peut appeler.
Officiellement, en C#, tout ça s’appelle des méthodes, mais si tu vois "fonction" plus loin, t’inquiète pas !
2. Syntaxe de déclaration d’une méthode : décryptage
Regardons une fonction toute simple, le classique "Hello, World!", mais on va mettre l’affichage dans une méthode à part :
using System;
class Program
{
static void Main()
{
PrintHello();
}
static void PrintHello() // affiche le texte Hello, World!
{
Console.WriteLine("Hello, World!");
}
}
Décryptage de la syntaxe :
| Partie | Exemple | Description |
|---|---|---|
| Modificateur | |
Indique que la méthode appartient à la classe (on verra plus tard) |
| Type de retour | |
Indique que la méthode ne renvoie rien |
| Nom de la méthode | |
Le nom pour appeler la méthode |
| Paramètres | |
Arguments (vide = pas d’arguments) |
| Corps de la méthode | |
Le code exécuté quand on appelle la méthode |
Petite analogie :
Une méthode, c’est comme une machine à café : tu mets de l’argent (arguments), tu appuies sur le bouton (tu appelles la méthode), la machine fait le café (corps de la méthode), et elle te donne le résultat (valeur de retour) — ou rien si c’est une void-méthode !
3. Comment appeler des méthodes
Appeler une méthode, c’est juste son nom et des parenthèses, c’est tout :
PrintHello(); // Méthode sans paramètres
int sum = Add(2, 3); // Méthode avec paramètres et résultat
Important : tu peux appeler une méthode seulement après l’avoir déclarée (ou si elle est "au-dessus" dans le code, ou dans la même classe).
4. Méthodes avec paramètres
On peut passer des paramètres à une méthode. Ça rend la méthode flexible et adaptable à plein de cas. En fait, les paramètres sont des variables de la méthode, auxquelles on donne des valeurs au moment de l’appel. Il faut les préciser quand tu crées la méthode.
static void Greet(string name)
{
Console.WriteLine($"Salut, {name}!");
}
// Utilisation :
Greet("Alice");
Greet("Bob");
Les paramètres — ce sont les variables dont tu donnes la valeur à la méthode quand tu l’appelles.
| Partie | Exemple | Description |
|---|---|---|
| Type du paramètre | |
Type de la valeur reçue |
| Nom du paramètre | |
Nom utilisé dans la méthode |
Appels :
Greet("Alice"); — name reçoit la valeur "Alice".
Plusieurs paramètres
Tu peux déclarer plusieurs paramètres séparés par des virgules :
static void PrintSum(int a, int b)
{
Console.WriteLine($"Somme : {a + b}");
}
// Utilisation :
PrintSum(5, 7); // Somme : 12
5. Paramètres-valeurs et paramètres-références
Les paramètres d’une fonction sont des variables normales, donc les mêmes règles s’appliquent.
Donc retiens : quand tu passes un tableau à une méthode, tu passes une référence au tableau, donc la méthode peut modifier le contenu du tableau. Pour les types simples (int, double), c’est la valeur qui est copiée.
static void ZeroFirstGrade(int[] grades)
{
grades[0] = 0; // Modifie le tableau d’origine !
}
// Utilisation :
int[] a = {1, 2, 3, 4, 5};
ZeroFirstGrade(a);
Console.WriteLine(a[0]); //affichera 0
En fait, voilà ce qui se passe :
static void ZeroFirstGrade(int[] grades)
{
grades[0] = 0; // Modifie le tableau d’origine !
}
// Utilisation :
int[] a = {1, 2, 3, 4, 5};
//ZeroFirstGrade(a);
int[] grades = a;
grades[0] = 0;
Console.WriteLine(a[0]); //affichera 0
GO TO FULL VERSION