Aller au menu - Aller au contenu

Icône Les méthodes

Par nico.pyright
Mise à jour : 02/02/2012
Difficulté : Facile Facile Creative Commons BY-NC-SA
22 955 visites depuis 7 jours, dont 666 sur ce chapitre classé 15/786
Élément indispensable de tout programme informatique, une méthode regroupe un ensemble d'instructions, pouvant prendre des paramètres et pouvant renvoyer une valeur. Lors de vos développements, vous allez avoir besoin de créer beaucoup de méthodes.

Nous allons découvrir les méthodes dans ce chapitre mais nous y reviendrons petit à petit tout au long de ce cours et vous aurez ainsi l'occasion d'approfondir vos connaissances.

Vous pourrez trouver de temps en temps le mot « fonction » à la place du mot « méthode ». Cela signifie la même chose.
C'est une relique du passé correspondant à un ancien mode de développement qui s'utilise de moins en moins, de même que le terme « procédure » qui est encore plus vieux !
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Créer une méthode

Le but de la méthode est de factoriser du code afin d’éviter d’avoir à répéter sans arrêt le même code et ceci pour deux raisons essentielles :
  • Déjà parce que l’homme est un être paresseux qui utilise son intelligence pour éviter le travail inutile.
  • Ensuite parce que si jamais il y a quelque chose à corriger dans ce bout de code et s’il est dupliqué à plusieurs endroits, alors nous allons devoir faire une correction dans tous ces endroits. Si le code est factorisé à un unique endroit, nous ferons une unique correction. (Oui oui, encore la paresse mais aussi cela permet d’éviter d’oublier un bout de code dans un endroit caché).

Ce souci de factorisation est connu comme le principe « DRY » qui est l’acronyme des mots anglais « Don’t Repeat Yourself », ce qui veut bien sûr dire : « Ne vous répétez pas ». Le but de ce principe est de ne jamais (à quelques exceptions près bien sûr …) avoir à réécrire la même ligne de code.

Par exemple, imaginons quelques instructions qui s’occupent d’écrire un message de bienvenue avec le nom de l’utilisateur. Le code C# pourrait être :

Code : C#
1
2
3
Console.WriteLine("Bonjour Nicolas");
Console.WriteLine("-------" + Environment.NewLine);
Console.WriteLine("\tBienvenue dans le monde merveilleux du C#");

Note : Dans l’instruction Console.WriteLine que nous utilisons régulièrement, WriteLine est une méthode.


Si plus tard, on veut ré-afficher le message de bienvenue, il faudra réécrire ces 4 lignes de codes. Sauf si nous utilisons une méthode :

Code : C#
1
2
3
4
5
6
static void AffichageBienvenue()
{
    Console.WriteLine("Bonjour Nicolas");
    Console.WriteLine("-------" + Environment.NewLine);
    Console.WriteLine("\tBienvenue dans le monde merveilleux du C#");
}


Dans l’exemple précédent, je définis une méthode qui s’appelle AffichageBienvenue.

L’instruction :

Code : C#
1
static void AffichageBienvenue()


est ce qu’on appelle la signature de la méthode. Elle nous renseigne sur les paramètres de la méthode et sur ce qu’elle va renvoyer.
Le mot clé void signifie que la méthode ne renvoie rien. Les parenthèses vides à la fin de la signature indiquent que la méthode n’a pas de paramètres.

C’est la forme de la méthode la plus simple possible.



Le mot clé static ne nous intéresse pas pour l’instant, mais sachez qu’il sert à indiquer que la méthode est toujours disponible et prête à être utilisée. Dans ce contexte, il est obligatoire. Nous y reviendrons.

En-dessous de la signature de la méthode, nous retrouvons les accolades. Elles permettent de délimiter la méthode. Le bloc de code ainsi formé constitue ce qu’on appelle le « corps de la méthode ».

En résumé, pour déclarer une méthode, nous aurons :

Code : Autre
1
2
3
4

Signature de la méthode
{
    Bloc de code de la méthode
}


Nous pouvons désormais appeler (c'est-à-dire : exécuter) cette méthode dans notre programme grâce à son nom. Par exemple, ici je l’appelle très facilement 2 fois de suite :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
static void Main(string[] args)
{
    AffichageBienvenue();
    AffichageBienvenue();
}

static void AffichageBienvenue()
{
    Console.WriteLine("Bonjour Nicolas");
    Console.WriteLine("-------" + Environment.NewLine);
    Console.WriteLine("\tBienvenue dans le monde merveilleux du C#");
}


Et tout ça, sans efforts ! C’est quand même plus simple et plus clair, non ?

Retour en haut

La méthode spéciale Main()

La signature de la méthode que l’on vient de créer ne vous rappelle rien ? Mais si, l’autre bloc au-dessus de notre méthode, qui ressemble lui aussi à une méthode.

Il s’agit d’une méthode spéciale, la méthode Main().

Elle a été générée par Visual C# express lorsque nous avons créé le projet Console.

Cette méthode est en fait le point d’entrée de l’application, c’est-à-dire que quand le CLR tente d’exécuter notre application, il recherche cette méthode afin de pouvoir commencer à exécuter des instructions à partir d’elle. S’il ne la trouve pas, alors, il ne pourra pas exécuter notre application. C’est pour cela qu’il est important que cette méthode soit accessible de partout ; rappelez-vous, c’est grâce au mot clé static que nous aurons l’occasion d’étudier plus en détail ultérieurement.
Visual C# express nous garde bien de cette erreur. En effet, si vous supprimez cette méthode (ou que vous enlevez le mot clé static) et que vous tentez de compiler notre application, vous aurez le message d’erreur suivant :

Citation : Compilateur
Erreur 1 Le programme 'C:\Users\Nico\Documents\Visual Studio 2010\Projects\C#\MaPremiereApplication\MaPremiereApplication\obj\x86\Release\MaPremiereApplication.exe' ne contient pas une méthode 'Main' statique appropriée pour un point d'entrée

Le message d’erreur est clair. Il a besoin d’une méthode Main() pour démarrer.

Voilà pour cette méthode spéciale Main(). Elle est indispensable dans tout programme exécutable et c’est par là que le programme démarre.

Les lecteurs attentifs auront remarqué que cette méthode possède des choses dans la signature, entre les parenthèses … Des paramètres ! Découvrons-les dans le prochain chapitre…
Retour en haut

Paramètres d’une méthode

Super, nous savons créer des méthodes. Nous allons pouvoir créer une méthode qui permet de souhaiter la bienvenue à la personne qui vient de se connecter à notre application par exemple. Si c’est Nicolas qui vient de se connecter, nous allons pouvoir appeler la méthode AffichageBienvenueNicolas(). Si c’est Jérémie, nous appellerons la méthode AffichageBienvenueJeremie(), etc …

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
static void AffichageBienvenueNicolas()
{
    Console.WriteLine("Bonjour Nicolas");
    Console.WriteLine("-------" + Environment.NewLine);
    Console.WriteLine("\tBienvenue dans le monde merveilleux du C#");
}

static void AffichageBienvenueJeremie()
{
    Console.WriteLine("Bonjour Jérémie");
    Console.WriteLine("-------" + Environment.NewLine);
    Console.WriteLine("\tBienvenue dans le monde merveilleux du C#");
}



Bof… finalement, ce n’est pas si super que ça en fait. Alors que nous venions juste d’évoquer le principe DRY, nous nous retrouvons avec deux méthodes quasiment identiques qui ne diffèrent que d’une toute petite chose.

C’est là qu’interviennent les paramètres de méthodes. Nous l’avons évoqué au paragraphe précédent, il est possible de passer des paramètres à une méthode. Ainsi, nous pourrons utiliser les valeurs de ces paramètres dans le corps de nos méthodes, les méthodes en deviendront d’autant plus génériques.

Dans notre exemple d’affichage de message de bienvenue, il est évident que le nom de l’utilisateur sera un paramètre de la méthode.

Les paramètres s’écrivent à l’intérieur des parenthèses qui suivent le nom de la méthode. Nous devons indiquer le type du paramètre ainsi que le nom de la variable qui le représentera au sein de la méthode.

Il est possible de passer plusieurs paramètres à une méthode, on les séparera avec une virgule. Par exemple :

Code : C#
1
2
3
4
5
static void DireBonjour(string prenom, int age)
{
    Console.WriteLine("Bonjour " + prenom);
    Console.WriteLine("Vous avez " + age + " ans");
}

Ici, la méthode DireBonjour prend en paramètres une chaine de caractères prenom et un entier age.
La méthode affiche « Bonjour » ainsi que le contenu de la variable prenom. De même, juste en dessous, elle affiche l’âge qui a été passé en paramètres.

Nous pourrons appeler cette méthode de cette façon, depuis la méthode Main() :

Code : C#
1
2
3
4
5
static void Main(string[] args)
{
    DireBonjour("Nicolas", 30);
    DireBonjour("Jérémie", 20);
}


Et nous aurons :

Image utilisateur


Bien sûr, il est obligatoire de fournir en paramètres d’une méthode une variable du même type que le paramètre. Sinon, le compilateur sera incapable de mettre la donnée qui a été passée dans le paramètre. D’ailleurs, si vous ne fournissez pas le bon paramètre, vous aurez droit à une erreur de compilation.

Par exemple, si vous appelez la méthode avec les paramètres suivants :

Code : C#
1
DireBonjour(10, 10);


Vous aurez l’erreur de compilation suivante :

Citation : Compilateur
impossible de convertir de 'int' en 'string'


Il est évidemment possible de passer des variables à une méthode, cela fonctionne de la même façon :

Code : C#
1
2
string prenom = "Nicolas";
DireBonjour(prenom, 30);

Nous allons revenir plus en détail sur ce qu’il se passe exactement ici dans le chapitre sur le mode de passage des paramètres.

Vous voyez, cela ressemble beaucoup à ce que nous avons déjà fait avec la méthode Console.WriteLine(). Facile, non ? :)

La méthode Console.WriteLine fait partie de la bibliothèque du framework .NET et est utilisée pour écrire des chaines de caractères, des nombres ou plein d’autres choses sur la console. Le framework .NET contient énormément de méthodes utilitaires de toutes sortes, nous y reviendrons.

Vous aurez peut-être remarqué un détail, nous avons préfixé toutes nos méthodes du mot clé static. J’ai dit que c’était obligatoire dans notre contexte, pour être plus précis, c’est parce que la méthode Main() est statique que nous sommes obligés de créer des méthodes statiques. On a dit que la méthode Main() était obligatoirement statique parce qu’elle devait être accessible de partout afin que le CLR puisse trouver le point d’entrée de notre programme. Or, une méthode statique ne peut appeler que des méthodes statiques, c’est pour cela que nous sommes obligés (pour l’instant) de préfixer nos méthodes par le mot clé static. Nous décrirons ce que recouvre exactement le mot clé static dans la partie suivante.
Retour en haut

Retour d’une méthode

Une méthode peut aussi renvoyer une valeur, par exemple un calcul. C’est souvent d’ailleurs son utilité première.

On pourrait imaginer par exemple une méthode qui calcule la longueur de l’hypoténuse à partir des 2 côtés d’un triangle. Sachant que a² + b² = c², nous pouvons imaginer une méthode qui prend en paramètres la longueur des 2 cotés, fait la somme de leur carrés et renvoie la racine carré du résultat. C’est ce que fait la méthode suivante :

Code : C#
1
2
3
4
5
6
static double LongueurHypotenuse(double a, double b)
{
    double sommeDesCarres = a * a + b * b;
    double resultat = Math.Sqrt(sommeDesCarres);
    return resultat;
}


Continuons à ignorer le mot clé static. Vous aurez remarqué que la signature de la méthode commence par le mot clé double, qui indique que la méthode va nous renvoyer une valeur du type double. Comme on l’a vu, double a et double b sont deux paramètres de la méthode et sont du type double.

La méthode Math.Sqrt est une méthode du framework .NET, au même titre que la méthode Console.WriteLine, qui permet de renvoyer la racine carrée d’un nombre. Elle prend en paramètre un double et nous retourne une valeur de type double également qui correspond à la racine carrée du paramètre. C’est tout naturellement que nous stockons ce résultat dans une variable grâce à l’opérateur d’affectation « = ».

À la fin de la méthode, le mot clé return indique que la méthode renvoie la valeur à la méthode qui l’a appelée. Ici, nous renvoyons le résultat.

Cette méthode pourra s’utiliser ainsi :

Code : C#
1
2
3
4
5
6
7
static void Main(string[] args)
{
    double valeur = LongueurHypotenuse(1, 3);
    Console.WriteLine(valeur);
    valeur = LongueurHypotenuse(10, 10);
    Console.WriteLine(valeur);
}


Comme précédemment, nous utilisons une variable pour stocker le résultat de l’exécution de la méthode.

Ce qui produira comme résultat :

Image utilisateur



À noter qu’il est également possible de se passer d’une variable intermédiaire pour stocker le résultat. Ainsi, nous pourrons par exemple faire :

Code : C#
1
Console.WriteLine("Le résultat est : " + LongueurHypotenuse(1, 3));


Avec cette écriture le résultat renvoyé par la méthode LongueurHypotenuse est directement concaténé à la chaine "Le résultat est : " et est passé en paramètre à la méthode Console.WriteLine.

Remarquez qu’on a fait l’opération a*a pour mettre « a » au carré. On aurait également pu faire Math.Pow(a, 2) qui permet de faire la même chose, la différence est que Pow permet de mettre à la puissance que l’on souhaite. Ainsi, Math.Pow(a, 3) permet de mettre « a » au cube.

Il faut savoir que le mot clé return peut apparaitre à n’importe quel endroit de la méthode. Il interrompt alors l’exécution de celle-ci et renvoie la valeur passée. Ce mot-clé est obligatoire, sans cela la méthode ne compilera pas.

Il est également primordial que tous les chemins possibles d’une méthode renvoient quelque chose. Les chemins sont déterminés par les instructions conditionnelles que nous avons vues précédemment.

Ainsi, l’exemple suivant est correct :

Code : C#
1
2
3
4
5
6
7
static string Conjugaison(string genre)
{
    if (genre == "homme")
        return "é";
    else
        return "ée";
}


car peu importe la valeur de la variable « genre », la méthode renverra une chaine.

Alors que celui-ci :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
static string Conjugaison(string genre)
{
    if (genre == "homme")
        return "é";
    else
    {
        if (genre == "femme")
            return "ée";
    }
}


est incorrect. En effet, que renvoie la méthode si la variable « genre » contient autre chose que homme ou femme ?

En général, Visual C# express nous indiquera qu’il détecte un problème avec une erreur de compilation.

Nous pourrons corriger ceci avec par exemple :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
static string Conjugaison(string genre)
{
    if (genre == "homme")
        return "é";
    else
    {
        if (genre == "femme")
            return "ée";
    }
    return "";
}


À noter que "" correspond à une chaine vide et peut également s’écrire : string.Empty.


Nous avons vu dans le chapitre précédent qu’il était possible de créer des méthodes qui ne retournent rien. Dans ce cas, on peut utiliser le mot clé return sans valeur qui le suit pour stopper l’exécution de la méthode. Par exemple :

Code : C#
1
2
3
4
5
6
static void Bonjour(string prenom)
{
    if (prenom == "inconnu")
        return;
    Console.WriteLine("Bonjour " + prenom);
}


Ainsi, si la variable « prenom » vaut « inconnu », alors nous quittons la méthode Bonjour et l’instruction Console.WriteLine ne sera pas exécutée.
Retour en haut

Q.C.M.

Que faut-il mettre à la place des XXXXX pour créer une méthode qui renvoi un entier, que l'on souhaite appeler depuis la méthode Main() ?

Code : C#
1
2
3
4
XXXXX DireBonjour(string prenom)
{

}
Le code suivant est-il correct ?

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
static void Main(string[] args)
{
    DireBonjour("Inconnu");
}

static void DireBonjour(string prenom)
{
    switch (prenom)
    {
        case "Nicolas":
        case "Jérémie":
            Console.WriteLine("Bonjour cher utlisateur");
            return;
    }
}
Ce programme ne compile pas, pourquoi ?

Code : C#
1
2
3
4
5
6
7
8
9
static void Main(string[] args)
{
    Console.WriteLine(Adition(1, 2));
}

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

Statistiques de réponses au QCM

Retour en haut

En résumé


  • Une méthode regroupe un ensemble d’instructions pouvant prendre des paramètres et pouvant renvoyer une valeur.
  • Les paramètres d'une méthode doivent être utilisés avec le bon type.
  • Une méthode qui ne renvoie rien est préfixée du mot-clé void.
  • Le point d'entrée d'un programme est la méthode statique Main().
  • Le mot-clé return permet de renvoyer une valeur du type de retour de la méthode, à l'appelant de cette méthode.
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
10 commentaires pour "Les méthodes"
Note moyenne : 3.05 / 4 (230 votes)
Pseudo Commentaire
Hors ligne nico.pyright # Posté le 27/01/2012 à 13:50:55
Groupe : Auteurs

Bonjour, en fait, il n'y a que 2 réponses, il s'agit juste d'un saut de ligne dans la réponse.
Par contre, ce sont bien des méthodes car elles font parties d'une classe.
Mon livre pour apprendre le C#
 
Hors ligne salaani # Posté le 21/03/2012 à 16:36:03

Avis : Bon

Console.WriteLine("Bonjour Nicolas");
Console.WriteLine("-------" + Environment.NewLine);
Console.WriteLine("\tBienvenue dans le monde merveilleux du C#");

what it mean Environment.NewLine? PLEAZE answer mee
Hors ligne nico.pyright # Posté le 21/03/2012 à 18:07:07
Groupe : Auteurs

Environment.NewLine is equivalent to \n
Mon livre pour apprendre le C#
 
Hors ligne king2012 # Posté le 07/04/2012 à 00:03:13

Avis : Très bon

Pour éviter l’erreur ou cas où la variable "genre" contient autre chose que "homme" ou "femme", on peut aussi écrire le code suivant :

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
static string Conjugaison(string genre)
        {
            string str = "";

            if (genre == "homme")
                str = "é";
            else if (genre == "femme")
                str = "ée";

            return str;
        }
Hors ligne vhansoftkindo # Posté le 20/05/2012 à 18:59:15

Avis : Bon

Bonjour,

Merci pour ton tuto

Voir tous les commentaires