• 20 hours
  • Easy

Free online content available in this course.

Paperback available in this course

course.header.alt.is_certifying

You can get support and mentoring from a private teacher via videoconference on this course.

Got it!

Last updated on 11/28/19

Les méthodes

Log in or subscribe for free to enjoy all this course has to offer!

É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’appelle AffichageBienvenue.

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

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 :

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é static que 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éthode Main() 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éthode AffichageBienvenueNicolas(). Si c’est Jérémie, nous appellerons la méthode AffichageBienvenueJeremie(), 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é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() :

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é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 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 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 :

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é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 :

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é return sans 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éthode Bonjour et l’instruction Console.WriteLine ne 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 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.

Example of certificate of achievement
Example of certificate of achievement