Tutoriel : Apprendre à déboguer du code C# à l’aide de Visual Studio

Cet article présente les fonctionnalités du débogueur Visual Studio dans une procédure pas à pas. Si vous souhaitez une vue de niveau supérieur des fonctionnalités du débogueur, consultez Premier aperçu du débogueur. Lorsque vous déboguez votre application, cela signifie généralement que vous exécutez votre application avec le débogueur activé. Lorsque vous effectuez cette tâche, le débogueur fournit de nombreuses façons de voir ce que fait votre code pendant son exécution. Vous pouvez parcourir votre code et examiner les valeurs stockées dans des variables, vous pouvez définir des montres sur les variables pour voir quand les valeurs changent, vous pouvez examiner le chemin d’exécution de votre code, voir si une branche de code est en cours d’exécution, et ainsi de suite. Si c'est la première fois que vous essayez de déboguer du code avec cet exercice, vous voudrez peut-être lire Débogage pour les débutants absolus avant de passer à cet article.

Bien que l’application de démonstration soit C#, la plupart des fonctionnalités s’appliquent à C++, Visual Basic, F#, Python, JavaScript et d’autres langages pris en charge par Visual Studio (F# ne prend pas en charge edit-and-continue). F# et JavaScript ne prennent pas en charge la fenêtre Autos). Les captures d’écran sont en C#.

Dans ce tutoriel, vous allez :

Démarrer le débogueur et atteindre des points d’arrêt.
Découvrir les commandes pour parcourir le code dans le débogueur
Inspecter des variables dans des bulles d’informations et dans les fenêtres du débogueur
Examiner la pile des appels

Conditions préalables

Vous devez avoir Visual Studio 2022 installé ainsi que la charge de travail de développement de bureau .NET .

Si vous n’avez pas encore installé Visual Studio, accédez à la page Téléchargements Visual Studio pour l’installer gratuitement.

Si vous disposez déjà de Visual Studio, mais que la charge de travail Développement .NET Desktop n’est pas installée, accédez à Outils>Obtenir des outils et des fonctionnalités..., ce qui lance Visual Studio Installer. Dans Visual Studio Installer, choisissez la charge de travail Développement .NET Desktop, puis Modifier.

Créer un projet

Tout d’abord, vous créez un projet d’application console .NET Core. Le type de projet est fourni avec tous les fichiers de modèle dont vous avez besoin, avant même d’avoir ajouté quoi que ce soit !

Ouvrez Visual Studio. Si la fenêtre de démarrage n’est pas ouverte, sélectionnez Fichier>Fenêtre de démarrage.
Dans la fenêtre de démarrage, sélectionnez Créer un projet.

Dans la fenêtre Créer un projet, entrez console dans la zone de recherche. Ensuite, choisissez C# dans la liste de langues, puis choisissez Windows dans la liste plateforme.

Après avoir appliqué les filtres de langue et de plateforme, choisissez le modèle Application Console, puis sélectionnez Suivant.

Note

Si vous ne voyez pas le modèle application console, vous pouvez l’installer à partir de la fenêtre Créer un projet. Dans le message Vous ne trouvez pas ce que vous cherchez ?, choisissez le lien Installer d’autres outils et fonctionnalités. Dans Visual Studio Installer, choisissez ensuite la charge de travail Développement .NET Desktop.
Dans la fenêtre Configurer votre nouveau projet, entrez GetStartedDebugging dans la zone Nom du projet. Ensuite, sélectionnez Suivant.
Dans la fenêtre Informations supplémentaires, vérifiez que .NET 8.0 est sélectionné dans le menu déroulant Framework, puis sélectionnez Créer.

Visual Studio ouvre votre nouveau projet.

Créer l’application

Dans Program.cs, remplacez tout le code par défaut par le code suivant :

using System;

class ArrayExample
{
   static void Main()
   {
      char[] letters = { 'f', 'r', 'e', 'd', ' ', 's', 'm', 'i', 't', 'h'};
      string name = "";
      int[] a = new int[10];
      for (int i = 0; i < letters.Length; i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
      Console.ReadKey();
   }

   static void SendMessage(string name, int msg)
   {
      Console.WriteLine("Hello, " + name + "! Count to " + msg);
   }
}

Démarrez le débogueur !

Principalement, nous utilisons des raccourcis clavier ici, car il s’agit d’un moyen rapide d’exécuter des commandes de débogueur. Les commandes équivalentes, telles que les commandes de barre d’outils ou de menu, sont également indiquées.

Pour démarrer le débogueur, sélectionnez F5, ou choisissez le bouton cible de débogage dans la barre d’outils Standard, ou choisissez le bouton Démarrer le débogage dans la barre d’outils Débogage, ou choisissez DéboguerDémarrer le débogage> dans la barre de menus.

F5 démarre l’application avec le débogueur attaché au processus d’application. Comme nous n’avons rien fait de spécial pour examiner le code, l’application s’exécute jusqu’à la fin et vous voyez la sortie de la console.
```
Hello, f! Count to 1
Hello, fr! Count to 2
Hello, fre! Count to 3
Hello, fred! Count to 4
Hello, fred ! Count to 5
Hello, fred s! Count to 6
Hello, fred sm! Count to 7
Hello, fred smi! Count to 8
Hello, fred smit! Count to 9
Hello, fred smith! Count to 10
```
Pour arrêter le débogueur, sélectionnez Maj+F5, ou choisissez le bouton Arrêter le débogage dans la barre d’outils Déboguer, ou choisissez Déboguer>Arrêter le débogage dans la barre de menus.
Dans la fenêtre de console, sélectionnez n’importe quelle clé pour fermer la fenêtre de console.

Définir un point d’arrêt et démarrer le débogueur

Dans la boucle for de la fonction Main, définissez un point d’arrêt en cliquant dans la marge gauche sur la ligne de code suivante :

name += letters[i];

Un cercle rouge apparaît où vous définissez le point d’arrêt.

Les points d’arrêt constituent une fonctionnalité essentielle pour un débogage fiable. Vous pouvez définir des points d’arrêt dans lesquels Visual Studio doit suspendre votre code en cours d’exécution afin de pouvoir examiner les valeurs des variables ou le comportement de la mémoire, ou savoir si une branche de code est en cours d’exécution.
Pour démarrer le débogage, sélectionnez F5, ou choisissez le bouton Debug Target dans la barre d’outils Standard, ou choisissez le bouton Démarrer le débogage dans la barre d’outils Débogage, ou choisissez Déboguer>Démarrer le débogage dans la barre de menus. L’application démarre et le débogueur s’exécute jusqu'à la ligne de code où vous avez défini le point d’arrêt.

La flèche jaune pointe vers l’instruction sur laquelle le débogueur s’est arrêté. L’exécution de l’application est suspendue au même point, l’instruction n’ayant pas encore été exécutée.

Lorsque l’application n’est pas en cours d’exécution, F5 démarre le débogueur, qui exécute l’application jusqu’à ce qu’elle atteigne le premier point d’arrêt. Si l’application est suspendue à un point d’arrêt, F5 continue d’exécuter l’application jusqu’à ce qu’elle atteigne le point d’arrêt suivant.

Les points d’arrêt sont une fonctionnalité utile lorsque vous connaissez la ligne ou la section du code que vous souhaitez examiner en détail. Pour plus d’informations sur les différents types de points d’arrêt que vous pouvez définir, tels que les points d’arrêt conditionnels, consultez Utilisation de points d’arrêt.

Naviguer dans le code et inspecter les données à l’aide de conseils sur les données

L’exécution du code étant interrompue sur l’instruction name += letters[i], placez le curseur sur la variable letters pour afficher une info-bulle de données montrant la taille du tableau et le type d’élément, char[10].

Note

L’une des fonctionnalités les plus utiles du débogueur est sa capacité à inspecter une variable. Souvent, lorsque vous essayez de déboguer un problème, vous tentez de déterminer si les variables ont des valeurs attendues à un moment donné. L’affichage des conseils sur les données est un bon moyen de vérifier cela.
Développez la variable letters pour afficher tous ses éléments de tableau et leurs valeurs.
Pointez sur la variable name pour voir sa valeur actuelle, qui est une chaîne vide.
Pour faire passer le débogueur à l’instruction suivante, sélectionnez F10, ou choisissez le bouton Rechercher à pas dans la barre d’outils Déboguer, ou choisissez Déboguer>Rechercher à pas dans la barre de menus. Sélectionnez F10 deux fois plus pour passer l’appel de méthode SendMessage.

F10 fait avancer le débogueur sans effectuer de pas à pas détaillé dans les fonctions ou les méthodes, mais leur code s’exécute néanmoins. De cette façon, nous avons ignoré le débogage du code dans la méthode SendMessage, qui ne nous intéresse pas pour l’instant.
Pour effectuer une itération au sein de la boucle for plusieurs fois, sélectionnez F10 à plusieurs reprises. Pendant chaque itération de boucle, effectuez une pause au point d’arrêt, puis pointez sur la variable name pour vérifier sa valeur dans l’info-bulle de données.

La valeur de la variable change avec chaque itération de la boucle for, affichant les valeurs de f, puis fr, puis fre, et ainsi de suite. Pour faire avancer le débogueur dans la boucle plus rapidement, sélectionnez plutôt F5, qui progresse jusqu’à votre point d’arrêt au lieu de l’instruction suivante.
Pendant que l’exécution du code est suspendue dans la boucle for de la méthode Main, sélectionnez F11, ou choisissez le bouton Pas à pas dans dans la barre d’outils Debug, ou choisissez Déboguer>Pas à pas dans dans la barre de menus jusqu’à atteindre l’appel de méthode SendMessage.

Le débogueur doit être suspendu à cette ligne de code :

SendMessage(name, a[i]);
Pour passer à pas à la méthode SendMessage, sélectionnez à nouveau F11.

Le pointeur jaune avance dans la méthode SendMessage.

F11 vous aide à examiner plus en détail le flux d’exécution de votre code. Pour passer à une méthode à partir d’un appel de méthode, sélectionnez F11 . Par défaut, le débogueur ignore le pas à pas détaillé dans les méthodes non-utilisateur. Pour en savoir plus sur le débogage de code non-utilisateur, consultez Simplement mon code.

Une fois que vous avez terminé le débogage de la méthode SendMessage, vous êtes prêt à revenir à la boucle for de la méthode main.
Pour quitter la méthode SendMessage, sélectionnez Maj+F11, ou cliquez sur le bouton Pas à pas sortant dans la barre d’outils Déboguer, ou choisissez Déboguer>Pas à pas sortant dans la barre de menus.

La commande Pas à pas sortant reprend l’exécution de l’application et fait avancer le débogueur jusqu’au retour de la méthode ou fonction active.

Vous voyez le pointeur jaune revenir dans la boucle for de la méthode Main, arrêté à l’appel de la méthode SendMessage. Pour plus d’informations sur les différentes façons de parcourir votre code, consultez Naviguer dans le code avec le débogueur.

Naviguer dans le code à l’aide de Run to Click

Sélectionnez F5 pour passer à nouveau au point d’arrêt.
Dans l’éditeur de code, pointez sur l’appel de méthode Console.WriteLine dans la méthode SendMessage jusqu’à ce que le bouton Exécuter pour cliquer sur s’affiche. L’info-bulle du bouton indique « Lancer l’exécution jusqu’ici. »
Sélectionnez le bouton Exécuter jusqu’au clic. Sinon, avec votre curseur à l’instruction Console.WriteLine, sélectionnez Ctrl+F10. Vous pouvez également faites un clic droit sur l’appel de méthode Console.WriteLine, puis choisir Exécuter jusqu’au curseur dans le menu contextuel.

Le débogueur avance jusqu’à l’appel de méthode Console.WriteLine.

L’utilisation du bouton Exécuter pour cliquer sur est similaire à la définition d’un point d’arrêt temporaire et est pratique pour vous déplacer rapidement dans une région visible du code de votre application dans un fichier ouvert.

Redémarrer rapidement votre application

Pour réexécuter votre application à partir du début dans le débogueur, sélectionnez Ctrl+Maj+F5, ou choisissez le bouton Redémarrer dans la barre d’outils Débogage, ou choisissez Déboguer>Redémarrer dans la barre de menus.

Capture d’écran du bouton Redémarrer dans la barre d’outils Débogage de Visual Studio 2022.

Redémarrer arrête le débogueur, puis le redémarre en une seule étape. Lorsque le débogueur redémarre, il s’exécute jusqu'au premier point d’arrêt, qui est le point d’arrêt que vous avez précédemment défini à l’intérieur de la boucle for, et se met ensuite en pause.

Inspecter des variables avec les fenêtres Autos et Locals

Les fenêtres Auto et Variables locales affichent les valeurs des variables lorsque vous déboguez. Les fenêtres sont disponibles uniquement pendant une session de débogage. La fenêtre Autos affiche les variables utilisées sur la ligne actuelle où se trouve actuellement le débogueur et sur la ligne précédente. La fenêtre Locals affiche les variables définies dans l’étendue locale, qui est généralement la fonction ou la méthode actuelle.

Lorsque le débogueur est suspendu, affichez la fenêtre Autos en bas de l’éditeur de code.

Si la fenêtre Autos est fermée, sélectionnez Ctrl+D, A, ou choisissez Déboguer>Windows>Autos dans la barre de menus.
Pendant que le débogueur est toujours suspendu, consultez la fenêtre Variables locales, dans un onglet à côté de la fenêtre Auto.

Si la fenêtre Locals est fermée, sélectionnez Ctrl+D, L, ou choisissez Déboguer>Windows>Locals.
Dans la fenêtre Locals, développez la variable letters pour afficher ses éléments de tableau et leurs valeurs.

Pour plus d’informations sur les fenêtres Autos et Locals, consultez Inspecter les variables dans les fenêtres Autos et Locals.

Définir un espion

Vous pouvez spécifier une variable, ou une expression, que vous souhaitez garder un œil sur pendant que vous parcourez le code, en l’ajoutant à la fenêtre Surveillance.

Pendant que le débogueur est suspendu, cliquez avec le bouton droit sur la variable name et choisissez Ajouter une montre.

La fenêtre Espion s’ouvre par défaut en bas de l’éditeur de code.
Maintenant que vous avez défini une montre sur la variable name, parcourez votre code pour voir la valeur de la variable name changer avec chaque itération de boucle for.

Contrairement aux autres fenêtres de variables, la fenêtre Observation affiche toujours les variables que vous suivez. Les variables hors portée sont affichées comme indisponibles.

Pour plus d’informations sur la fenêtre Espion, consultez Observer des variables avec les fenêtres Espion.

Examiner la pile des appels

La Pile des appels peut vous aider à comprendre le flux d’exécution de votre application, en montrant l’ordre dans lequel les méthodes et les fonctions sont appelées.

Pendant que le débogueur est suspendu dans la boucle for, consultez la fenêtre Pile des appels, qui s’ouvre par défaut dans le volet inférieur droit de l’éditeur de code.

Si la fenêtre Pile des appels est fermée, sélectionnez Ctrl+D, C ou choisissez Déboguer>Fenêtres>Pile des appels dans la barre de menus.

Dans la fenêtre Pile des appels, vous voyez le pointeur jaune au niveau de la méthode Main active.
Sélectionnez F11 plusieurs fois, jusqu’à ce que le débogueur place l’application en pause dans la méthode SendMessage.

La ligne supérieure de la fenêtre de la pile d'appels affiche la fonction actuelle, qui est la méthode SendMessage. La deuxième ligne indique que la méthode SendMessage a été appelée à partir de la méthode Main.

Note

La fenêtre Pile des appels est similaire à la perspective Débogage dans certains IDE, comme Eclipse.

Dans la fenêtre Pile des appels, vous pouvez double-cliquer sur une ligne de code pour accéder à ce code source, ce qui change également l’étendue active inspectée par le débogueur. Cette action ne fait pas avancer le débogueur.

Vous pouvez également utiliser les menus contextuels de la fenêtre Pile des appels pour faire d’autres choses. Par exemple, vous pouvez insérer des points d’arrêt dans des fonctions spécifiées, faire avancer le débogueur avec Exécuter jusqu’au curseur ou examiner le code source.

Pour plus d’informations sur la pile d’appels , consultez Comment examiner la pile d’appels.

Étapes suivantes

Dans ce tutoriel, vous avez appris à démarrer le débogueur, à parcourir le code et à inspecter les variables. Vous souhaiterez peut-être obtenir un aperçu général des fonctionnalités du débogueur, ainsi que des liens vers plus d’informations.

Premier aperçu du débogueur

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-12-12