Exercice – Appeler les méthodes d’une classe .NET

12 minutes

Que vous l’ayez réalisé ou non, vous appelez des méthodes C# depuis votre première application « Hello, World! ». Cette application utilise la méthode WriteLine() de la classe Console pour afficher le message « Hello, World! ».

Toutefois, toutes les classes et méthodes ne sont pas implémentées de la même façon. Cette unité couvre certaines des variantes les plus répandues, que vous devez comprendre quand vous utilisez des méthodes de la bibliothèque de classes .NET. Plus important encore, vous allez découvrir comment rechercher et utiliser la documentation pour mieux comprendre chaque méthode.

Comment appeler des méthodes dans la bibliothèque de classes .NET

De votre expérience précédente avec la méthode Console.WriteLine(), vous devez déjà connaître les principes de base :

Commencez par taper le nom de la classe. Dans ce cas, le nom de la classe est Console.
Ajoutez l’opérateur d’accès aux membres, le symbole ..
Ajoutez le nom de la méthode. Dans ce cas, le nom de la méthode est WriteLine.
Ajoutez l’opérateur d’appel de méthode, qui est un jeu de parenthèses ().
Enfin, spécifiez les arguments transmis à la méthode, le cas échéant, entre les parenthèses de l’opérateur d’appel de méthode. Dans ce cas, vous spécifiez le texte que vous souhaitez que la méthode Console.WriteLine() écrive dans la console (par exemple, "Hello World!").

Selon la façon dont les développeurs ont conçu et implémenté la méthode donnée, vous pouvez avoir besoin de :

Passez des valeurs supplémentaires comme paramètres d’entrée.
Acceptez une valeur de retour.

Dans l’unité suivante, vous allez examiner comment transmettre des valeurs d’entrée à une méthode et comment une méthode peut être utilisée pour renvoyer une valeur à la routine d’appel.

Si certaines méthodes peuvent être appelées de la même façon que vous avez appelé Console.WriteLine(), d’autres méthodes de la bibliothèque de classes .NET nécessitent une approche différente.

Préparer votre environnement de programmation

Ce module comprend des activités de codage qui vous guident tout au long du processus de création et d’exécution des exemples de code. Si possible, effectuez ces activités en utilisant Visual Studio Code comme environnement de développement. L’utilisation de Visual Studio Code pour ces activités vous permet d’être plus à l’aise dans l’écriture et l’exécution de code dans un environnement de développement qui est utilisé par les professionnels du monde entier.

Ouvrez Visual Studio Code.

Vous pouvez utiliser le menu Démarrer de Windows (ou une ressource équivalente pour un autre système d’exploitation) pour ouvrir Visual Studio Code.
Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.
Dans la boîte de dialogue Ouvrir le dossier , accédez au dossier Windows Desktop.

Si vous conservez vos projets de code dans un autre dossier, vous pouvez utiliser cet emplacement à la place. Pour cette formation, l’important est d’avoir un emplacement facile à localiser et à mémoriser.
Dans la boîte de dialogue Ouvrir un dossier, sélectionnez Sélectionner un dossier.

Si une boîte de dialogue de sécurité vous demande si vous faites confiance aux auteurs, sélectionnez Oui.
Dans le menu Terminal de Visual Studio Code, sélectionnez Nouveau Terminal.

Notez qu’une invite de commandes dans le panneau Terminal affiche le chemin du dossier actif. Par exemple:
```
C:\Users\someuser\Desktop>
```
Remarque

Si vous travaillez sur votre propre PC plutôt que dans un bac à sable ou un environnement hébergé et que vous avez terminé d’autres modules Microsoft Learn de cette série sur C#, vous avez peut-être déjà créé un dossier de projet pour les exemples de code. Si c’est le cas, vous pouvez passer à l’étape suivante, qui est utilisée pour créer une application console dans le dossier TestProject.
À l’invite de commandes terminal, pour créer une application console dans un dossier spécifié, entrez l’invite suivante :
```
dotnet new console -o ./CsharpProjects/TestProject
```
Cette commande CLI .NET utilise un modèle de programme .NET pour créer un projet d’application console C# à l’emplacement du dossier spécifié. La commande crée les dossiers CsharpProjects et TestProject automatiquement, et utilise TestProject comme nom pour votre fichier .csproj.

Si un message s’affiche pour vous indiquer que les fichiers existent déjà, passez aux étapes suivantes. Vous allez réutiliser les fichiers projet existants.
Dans l’affichage EXPLORATEUR, développez le dossier CsharpProjects .

Vous devez voir le dossier TestProject et deux fichiers, un fichier de programme C# nommé Program.cs et un fichier projet C# nommé TestProject.csproj.
Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.
Dans la boîte de dialogue Ouvrir un dossier , sélectionnez le dossier CsharpProjects , puis sélectionnez Sélectionner un dossier.
Dans l’affichage EXPLORATEUR, développez le dossier TestProject, puis sélectionnez Program.cs.
Supprimez les lignes de code existantes.

Vous allez utiliser ce projet de console C# pour créer, générer et exécuter des exemples de code au cours de ce module.
Fermez le panneau du Terminal.

Appeler différentes sortes de méthodes dans la bibliothèque de classes .NET

Dans l’Éditeur Visual Studio Code, pour créer un exemple de code qui implémente les méthodes des classes System.Random et System.Console, entrez le code suivant :
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
Ce code simule un lancer de dé à l’aide de la méthode Random.Next() pour générer un nombre et de la méthode Console.WriteLine() pour afficher la valeur.

Remarque

Vous examinerez le code en détail plus loin dans cette unité.
Dans le menu Fichier Visual Studio Code, cliquez sur Enregistrer.
Dans l’affichage EXPLORATEUR, pour ouvrir un terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le terminal intégré.

Notez que le panneau Terminal inclut une invite de commandes qui affiche un chemin de dossier. Par exemple:
```
C:\Users\someuser\Desktop\CsharpProjects\TestProject>
```
Lorsque vous utilisez le terminal pour exécuter des commandes CLI .NET, les commandes s’exécutent à partir de l’emplacement du dossier affiché. Assurez-vous que votre dossier de code correspond au chemin de dossier affiché dans l’invite de commandes avant de générer ou d’exécuter votre code.
À l’invite de commande du terminal, pour exécuter votre code, tapez dotnet run, puis appuyez sur Entrée.

Notez qu’un nombre compris entre 1 et 6 s’affiche dans la sortie de la console (le nombre de points sur le dé). Si vous exécutez le code suffisamment de fois, vous verrez chacun des nombres 1 à 6 affichés.
Prenez une minute pour examiner la syntaxe utilisée pour accéder aux méthodes Next() et WriteLine().

Notez que vous utilisez différentes techniques pour accéder aux méthodes.
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
Dans la troisième ligne de code, vous incluez une référence à la classe Console et appelez directement la méthode Console.WriteLine(). Toutefois, vous utilisez une autre technique pour appeler la méthode Random.Next(). La raison pour laquelle vous utilisez deux techniques différentes est que certaines méthodes sont avec état et d’autres sans état. Vous examinez la différence entre les méthodes avec et sans état dans la section suivante.

Méthodes avec état et méthodes sans état

Dans les projets de développement de logiciels, le terme état est utilisé pour décrire la condition de l’environnement d’exécution à un moment spécifique dans le temps. À mesure que votre code s’exécute ligne par ligne, des valeurs sont stockées dans des variables. À tout moment de l’exécution, l’état actuel de l’application est la collection de toutes les valeurs stockées en mémoire.

Certaines méthodes ne dépendent pas de l’état actuel de l’application pour fonctionner correctement. En d’autres termes, les méthodes sans état sont implémentées de façon à pouvoir fonctionner sans référencer ni modifier des valeurs déjà stockées en mémoire. Les méthodes sans état sont également appelées méthodes statiques.

Par exemple, la méthode Console.WriteLine() ne dépend d’aucune valeur stockée en mémoire. Elle effectue sa fonction et se termine sans affecter en aucune façon l’état de l’application.

Cependant, d’autres méthodes doivent avoir accès à l’état de l’application pour fonctionner correctement. En d’autres termes, les méthodes avec état sont construites de telle façon qu’elles dépendent de valeurs stockées en mémoire par des lignes de code précédentes qui ont déjà été exécutées. Elles peuvent aussi modifier l’état de l’application en mettant à jour des valeurs ou en stockant de nouvelles valeurs en mémoire. Elles sont également appelées méthodes d’instance.

Les méthodes (d’instance) avec état font le suivi de leur état dans des champs, qui sont des variables définies sur la classe. Chaque nouvelle instance de la classe reçoit sa propre copie des champs où stocker l’état.

Une même classe peut prendre en charge des méthodes avec état et des méthodes sans état. Cependant, quand vous avez besoin d’appeler des méthodes avec état, vous devez d’abord créer une instance de la classe pour que la méthode puisse accéder à l’état.

Création d’une instance d’une classe

Une instance d’une classe est appelée en tant qu’objet. Pour créer une instance d’une classe, vous utilisez l’opérateur new. Examinez la ligne de code suivante qui crée une instance de la classe Random pour créer un objet appelé dice :

Random dice = new Random();

L’opérateur new fait plusieurs choses importantes :

Il demande d’abord une adresse dans la mémoire de l’ordinateur suffisamment grande pour stocker un nouvel objet basé sur la classe Random.
Il crée l’objet et le stocke à l’adresse mémoire.
Il retourne l’adresse mémoire pour permettre l’enregistrement de celle-ci dans l’objet dice.

À partir de là, quand l’objet dice est référencé dans le code, le runtime .NET effectue une recherche en arrière-plan pour donner l’illusion que vous travaillez directement avec l’objet lui-même.

Votre code utilise l’objet dice comme une variable qui stocke l’état de la classe Random. Lorsque vous appelez la méthode Next() sur l’objet dice, la méthode utilise l’état stocké dans l’objet dice pour générer un nombre aléatoire.

La dernière version du runtime .NET vous permet d’instancier un objet sans avoir à répéter le nom du type (appel du constructeur typé cible). Par exemple, le code suivant crée une instance de la classe Random :

Random dice = new();

L’intention est de simplifier la lisibilité du code. Vous utilisez toujours des parenthèses lors de l’écriture d’une expression new typée cible.

Pourquoi la méthode Next() est-elle une méthode avec état ?

Vous vous demandez peut-être pourquoi la méthode Next() a été implémentée comme méthode avec état. Les concepteurs de la bibliothèque de classes .NET ne pouvaient-ils pas trouver un moyen de générer un nombre aléatoire sans nécessiter d’état ? Et qu’est-ce qui est stocké ou référencé exactement par la méthode Next() ?

Voici des questions pertinentes. D’une façon générale, les ordinateurs sont bons pour suivre des instructions spécifiques visant à créer un résultat fiable et reproductible. Pour créer l’illusion de l’aléatoire, les développeurs de la méthode Next() ont décidé de capturer la date et l’heure jusqu’à la fraction de milliseconde, et de l’utiliser pour alimenter un algorithme qui produit un nombre différent à chaque fois. Bien que ce ne soit pas entièrement aléatoire, cela suffit pour la plupart des applications. L’état qui est capturé et conservé pendant la durée de vie de l’objet dice est la valeur de départ. Chaque appel suivant à la méthode Next() réexécute l’algorithme, mais garantit que la valeur de départ change, de sorte que la même valeur n’est pas (nécessairement) retournée.

Toutefois, pour utiliser la méthode Random.Next(), vous n’avez pas besoin de comprendre comment elle fonctionne. Il est important de savoir que certaines méthodes vous demandent de créer une instance d’une classe avant de les appeler, contrairement à d’autres.

Comment pouvez-vous déterminer si vous devez créer une instance d’une classe avant d’appeler ses méthodes ?

Une approche pour déterminer si une méthode est avec ou sans état consiste à consulter la documentation. La documentation contient des exemples qui montrent si la méthode doit être appelée à partir de l’instance de l’objet ou directement à partir de la classe.

Remarque

Vous devrez parfois faire défiler la page de documentation vers le bas pour trouver les exemples de code.

Au lieu de chercher dans la documentation du produit, vous pouvez tenter d’accéder à la méthode directement à partir de la classe elle-même. Si cela fonctionne, vous savez qu’il s’agit d’une méthode sans état. Le pire qui puisse se produire est de recevoir une erreur de compilation.

Essayez d’accéder directement à la méthode Random.Next() et voyez ce qui se passe.

Entrez la ligne de code suivante dans l’Éditeur Visual Studio Code :
```
int result = Random.Next();
```
Vous savez déjà que Next() est une méthode avec état, mais cet exemple montre comment l’Éditeur Visual Studio Code réagit lorsque vous essayez d’accéder à une méthode de manière incorrecte.
Notez qu’une ligne ondulée rouge s’affiche sous Random.Next, indiquant une erreur de compilation.

Si la méthode qui vous intéresse est sans état, aucune ligne rouge ne s’affiche.
Pointez sur la ligne rouge avec le pointeur de la souris.

Une fenêtre contextuelle doit s’afficher avec le message suivant :
```
(1,14): error CS0120: An object reference is required for the non-static field, method, or property 'Random.Next()'
```
Comme vous l’avez vu dans le code au début de l’unité, vous pouvez corriger cette erreur en créant une instance de la classe Random avant d’accéder à la méthode Next(). Par exemple:
```
Random dice = new Random();
int roll = dice.Next();
```
Dans ce cas, la méthode Next() est appelée sans paramètres d’entrée.

Récapitulatif

Pour appeler les méthodes d’une classe de la bibliothèque de classes .NET, vous utilisez le format ClassName.MethodName(), où le symbole . est l’opérateur d’accès aux membres permettant d’accéder à une méthode définie sur la classe, et où les symboles () sont les opérateurs d’appel de méthode.
Lors de l’appel d’une méthode sans état, vous n’avez pas besoin de créer d’abord une instance de sa classe.
Lors de l’appel d’une méthode avec état, vous devez créer une instance de la classe, puis accéder à la méthode sur l’objet.
Utilisez l’opérateur new pour créer une instance d’une classe.
Une instance d’une classe est appelée en tant qu’objet.