• 20 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 04/06/2020

Les méthodes

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

É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 !

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 :

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

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 :

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’appelleAffichageBienvenue.

L’instruction :

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évoidsignifie 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.

Le mot cléstaticne 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 :

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 :

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 ?

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.

Elle a été générée par Visual Studio 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éstaticque nous aurons l’occasion d’étudier plus en détail ultérieurement.
Visual Studio 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 2013\Projects\MaPremiereApplication\MaPremiereApplication\obj\Debug\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éthodeMain()pour démarrer.

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…

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éthodeAffichageBienvenueNicolas(). Si c’est Jérémie, nous appellerons la méthodeAffichageBienvenueJeremie(), etc …

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 :

static void DireBonjour(string prenom, int age)
{
    Console.WriteLine("Bonjour " + prenom);
    Console.WriteLine("Vous avez " + age + " ans");
}

Ici, la méthodeDireBonjourprend en paramètres une chaine de caractèresprenomet un entierage.
La méthode affiche « Bonjour » ainsi que le contenu de la variableprenom. 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éthodeMain():

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 :

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 :

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, que nous verrons dans un prochain cours.

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

La méthodeConsole.WriteLinefait 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éthodeMain()est statique que nous sommes obligés de créer des méthodes statiques. On a dit que la méthodeMain()é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éstaticdans la partie suivante.

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 :

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 aetdouble bsont deux paramètres de la méthode et sont du typedouble.

La méthodeMath.Sqrtest une méthode du framework .NET, au même titre que la méthodeConsole.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éreturnindique 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 :

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 :

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

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

Remarquez qu’on a fait l’opération a*a pour mettre « a » au carré. On aurait également pu faireMath.Pow(a, 2)qui permet de faire la même chose, la différence est quePowpermet 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éreturnpeut 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 :

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 :

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 Studio Express nous indiquera qu’il détecte un problème avec une erreur de compilation.

Nous pourrons corriger ceci avec par exemple :

static string Conjugaison(string genre)
{
    if (genre == "homme")
        return "é";
    else
    {
        if (genre == "femme")
            return "ée";
    }
    return "";
}

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éreturnsans valeur qui le suit pour stopper l’exécution de la méthode. Par exemple :

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éthodeBonjouret l’instructionConsole.WriteLinene sera pas exécutée.

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 statiqueMain().

  • Le mot-cléreturnpermet de renvoyer une valeur du type de retour de la méthode, à l'appelant de cette méthode.

Exemple de certificat de réussite
Exemple de certificat de réussite