Tutoriel : Découvrir comment déboguer du code Visual Basic à 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 attaché. 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 cet exercice est la première fois que vous avez essayé de déboguer du code, vous pouvez lire le débogage pour les débutants absolus avant de passer par cet article.

Bien que l’application de démonstration soit Visual Basic, la plupart des fonctionnalités s’appliquent à C#, C++, 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 Visual Basic.

Dans ce tutoriel, vous allez :

• Démarrez le débogueur et appuyez sur les 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

Prerequisites

Vous devez avoir Visual Studio 2019 installé et le module de développement multiplateforme .NET Core installé.

Si vous n’avez pas encore installé Visual Studio, allez sur la page des téléchargements de Visual Studio pour l’installer gratuitement.

Si vous avez besoin d’installer la charge de travail, mais que Visual Studio est déjà installé, accédez à ToolsGet Tools >and Features..., ce qui ouvre Visual Studio Installer. Le programme d’installation de Visual Studio démarre. Choisissez la charge de travail Développement .NET Desktop, puis choisissez Modifier.

Création d’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 !

1. Ouvrez Visual Studio. Si la fenêtre de démarrage n’est pas ouverte, sélectionnezFenêtre de démarrage du >.

2. Dans la fenêtre de démarrage, sélectionnezCréer un projet.

3. Dans la fenêtre Créer un projet , entrez la console dans la zone de recherche. Ensuite, choisissez Visual Basic 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 d’application console pour .NET Core, 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 recherchez ? Choisissez le lien Installer d’autres outils et fonctionnalités . Ensuite, dans Visual Studio Installer, choisissez la charge de travail de développement de bureau .NET .

4. Dans la fenêtre Configurer votre nouveau projet , entrez get-started-debugging dans la zone Nom du projet . Ensuite, sélectionnez Suivant.

5. 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.vb, remplacez tout le code par défaut par le code suivant à la place :

Imports System

Class ArrayExample
  Public Shared Sub Main()
    Dim letters As Char() = {"f"c, "r"c, "e"c, "d"c, " "c, "s"c, "m"c, "i"c, "t"c, "h"c}
    Dim name As String = ""
    Dim a As Integer() = New Integer(9) {}

    For i As Integer = 0 To letters.Length - 1
      name += letters(i)
      a(i) = i + 1
      SendMessage(name, a(i))
    Next

    Console.ReadKey()
  End Sub

  Private Shared Sub SendMessage(ByVal name As String, ByVal msg As Integer)
    Console.WriteLine("Hello, " & name & "! Count to " & msg)
  End Sub
End Class

Démarrez le débogueur !

1. Appuyez sur F5 (>) ou sélectionnez le bouton Démarrer le débogage vert dans la barre d’outils de débogage.

   

   F5 démarre l’application avec le débogueur attaché au processus d’application, mais pour le moment, nous n’avons rien fait spécial pour examiner le code. Ainsi, l’application se charge simplement 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
   

   Dans ce tutoriel, vous allez examiner plus en plus près cette application à l’aide du débogueur et examiner les fonctionnalités du débogueur.

2. Arrêtez le débogueur en appuyant sur (Maj + F5) ou sélectionnez le bouton Rouge Arrêter le débogage dans la barre d’outils Debug.

   

3. Dans la fenêtre de console, appuyez sur une touche pour fermer la fenêtre de console.

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

1. Dans la For boucle de la Main fonction, 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 sont l’une des fonctionnalités les plus élémentaires et essentielles du débogage fiable. Un point d’arrêt indique où 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 si une branche de code est en cours d’exécution.

2. Appuyez sur F5 (Démarrer le débogage>) ou sur le bouton Démarrer le débogage dans la barre d’outils de débogage, l’application démarre et le débogueur s’exécute sur la ligne de code où vous avez défini le point d’arrêt.

   

   La flèche jaune représente l’instruction où le débogueur s'est arrêté, ce qui suspend également l’exécution de l’application à ce même point (cette instruction n'a pas encore été exécutée).

   Si l’application n’est pas encore en cours d’exécution, F5 démarre le débogueur et s’arrête au premier point d’arrêt. Sinon, F5 continue d’exécuter l’application jusqu’au point d’arrêt suivant.

   Les points d’arrêt sont une fonctionnalité utile lorsque vous connaissez la ligne de code ou la section de 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 dans le débogueur à l’aide des commandes pas à pas

Dans cet article, nous utilisons les raccourcis clavier, car il est judicieux d’exécuter rapidement votre application dans le débogueur (commandes équivalentes telles que les commandes de menu sont affichées entre parenthèses).

1. Pendant que l’exécution du code est suspendue dans la boucle For de la méthode Main, appuyez sur F11 (ou choisissez Déboguer > Entrer Dans) deux fois pour passer à l’appel de méthode SendMessage.

   Après avoir appuyé deux fois sur F11 , vous devez être à cette ligne de code :

   SendMessage(name, a(i))

2. Appuyez sur F11 encore une fois pour entrer dans la SendMessage méthode.

   Le pointeur jaune avance dans la SendMessage méthode.

   

   F11 est la commande Pas à pas et avance l’exécution de l’application une instruction à la fois. F11 est un bon moyen d’examiner le flux d’exécution en détail. (Pour parcourir plus rapidement le code, nous vous montrons également d’autres options.) Par défaut, le débogueur ignore le code non-utilisateur (si vous souhaitez plus de détails, consultez Simplement mon code).

   Supposons que vous avez terminé d’examiner la SendMessage méthode et que vous voulez quitter la méthode, mais rester dans le débogueur. Vous pouvez le faire à l’aide de la commande Step Out .

3. Appuyez sur Maj + F11 (ou Déboguer > Sortir).

   Cette commande reprend l’exécution de l’application (et avance le débogueur) jusqu’à ce que la méthode ou la fonction actuelle retourne.

   Vous devez revenir dans la boucle For de la méthode Main, en pause à l'appel de la méthode SendMessage.

4. Appuyez plusieurs fois sur F11 jusqu’à ce que vous reveniez à nouveau à l’appel SendMessage de méthode.

5. Pendant que l’exécution du code est suspendue au niveau de l’appel de méthode, appuyez sur F10 (ou choisissez Déboguer > pas à pas) une fois.

   

   Notez cette fois-ci que le débogueur n’effectue pas de pas à pas détaillé dans la méthode SendMessage. F10 avance le débogueur sans passer aux fonctions ou méthodes de votre code d’application (le code s’exécute toujours). En appuyant sur F10 sur l’appel SendMessage de méthode (au lieu de F11), nous avons ignoré le code d’implémentation pour SendMessage lequel nous ne sommes peut-être pas intéressés pour le moment. 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

1. Appuyez sur F5 pour passer à nouveau au point d’arrêt.

2. Dans l’éditeur de code, faites défiler vers le bas et pointez sur la Console.WriteLine méthode dans la SendMessage méthode jusqu’à ce que le bouton Run to Click vert s’affiche. L’info-bulle du bouton affiche « Exécuter l’exécution ici ».

   

3. Sélectionnez le bouton Exécuter pour cliquer .

   Le débogueur avance vers la Console.WriteLine méthode.

   L’utilisation de ce bouton est similaire à la définition d’un point d’arrêt temporaire. Exécuter pour cliquer est pratique pour vous déplacer rapidement dans une région visible du code de l’application (vous pouvez sélectionner dans n’importe quel fichier ouvert).

Redémarrer rapidement votre application

Pour redémarrer votre application, appuyez sur la combinaison de touches Ctrl + Maj + F5 , ce qui permet de gagner du temps par rapport à l’arrêt de l’application et de redémarrer le débogueur. Le débogueur s’interrompt au premier point d’arrêt atteint en exécutant du code.

Le débogueur s’arrête à nouveau au point d’arrêt que vous avez précédemment défini à l’intérieur de la For boucle.

Inspecter des variables avec des bulles d’informations (datatips)

Les fonctionnalités qui vous permettent d’inspecter les variables sont l’une des fonctionnalités les plus utiles du débogueur, et il existe différentes façons de le faire. Souvent, lorsque vous essayez de déboguer un problème, vous tentez de déterminer si les variables stockent les valeurs que vous attendez qu’elles aient à un moment donné.

1. Pendant que l’exécution du code est suspendue sur l’instructionname += letters[i], pointez sur la letters variable et voyez sa valeur par défaut, la valeur du premier élément du tableau. "f"c

2. Ensuite, pointez sur la name variable, et vous voyez sa valeur actuelle, une chaîne vide.

3. Appuyez sur F5 (ou Debug>Continue) plusieurs fois pour itérer plusieurs fois dans la For boucle, suspendre à nouveau au point d’arrêt et pointer sur la name variable chaque fois pour vérifier sa valeur.

   

   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.

   Souvent, lorsque vous déboguez, vous voulez un moyen rapide de vérifier les valeurs des propriétés des variables, pour voir si elles stockent les valeurs que vous attendez qu'elles stockent, et les infobulles de données sont un bon moyen de le faire.

Inspecter des variables avec les fenêtres Autos et Locals

1. Examinez la fenêtre Autos en bas de l’éditeur de code.

   S'il est fermé, ouvrez-le pendant que l'exécution du code est suspendue dans le débogueur en choisissant Debug>Windows>Autos.

   Dans la fenêtre Autos , vous voyez les variables et leur valeur actuelle. La fenêtre Autos affiche toutes les variables utilisées sur la ligne actuelle ou sur la ligne précédente (consultez la documentation relative au comportement spécifique au langage).

2. Ensuite, examinez la fenêtre Locals , dans un onglet en regard de la fenêtre Autos .

3. Développez la letters variable pour afficher les éléments qu’il contient.

   

   La fenêtre Locals affiche les variables qui se trouvent dans l’étendue actuelle, autrement dit le contexte d’exécution actuel.

Définir un espion

Vous pouvez spécifier une variable, ou une expression, que vous souhaitez garder un œil au fur et à mesure que vous parcourez le code, en l’ajoutant à la fenêtre Espion .

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

   La fenêtre Espion s’ouvre par défaut en bas de l’éditeur de code.

2. Maintenant que vous avez défini une montre sur la name variable, parcourez votre code pour voir la valeur de la name variable changer avec chaque for itération de boucle.

   Contrairement à d’autres fenêtres de variables, la fenêtre Espion présente toujours les variables que vous observez. Les variables hors portée sont affichées comme indisponibles.

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

Examiner la pile des appels

1. Pendant que l’exécution du code est suspendue dans la For boucle, sélectionnez la fenêtre Pile des appels , ouverte par défaut dans le volet inférieur droit.

   S’il est fermé, ouvrez-le pendant que l’exécution du code est suspendue dans le débogueur en choisissant Déboguer> lapile des appels>.

2. Sélectionnez F11 plusieurs fois jusqu’à ce que le débogueur s’interrompe dans la SendMessage méthode. Examinez la fenêtre Pile des appels .

   

   La fenêtre pile des appels affiche l’ordre dans lequel les méthodes et les fonctions sont appelées. La ligne supérieure affiche la fonction actuelle (la SendMessage méthode dans cette application). La deuxième ligne montre que SendMessage a été appelé(e) depuis la méthode Main, et ainsi de suite.

   Note

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

   La pile des appels est un bon moyen d’examiner et de comprendre le flux d’exécution d’une application.

   Vous pouvez double-cliquer sur une ligne de code pour examiner ce code source et modifier également l’étendue actuelle en cours d’inspection par le débogueur. Cette action n’avance pas 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 à l’aide de Run to Cursor et examiner le code source. Pour plus d’informations, consultez Guide pratique pour examiner la pile des appels.

Modifier le flux d’exécution

1. Appuyez deux fois sur F11 pour exécuter la Console.WriteLine méthode.

2. Avec le débogueur suspendu dans l’appel SendMessage de méthode, utilisez la souris pour saisir la flèche jaune ou le pointeur d’exécution (dans la marge gauche) et faites glisser le pointeur vers le haut d’une ligne vers l’instruction Console.WriteLine .

3. Appuyez sur F11.

   Le débogueur réexécute la Console.WriteLine méthode (vous voyez cette action dans la sortie de la fenêtre de console).

   En modifiant le flux d’exécution, vous pouvez effectuer des opérations telles que tester différents chemins d’exécution de code ou réexécuter du code sans redémarrer le débogueur.

   Avertissement

   Souvent, vous devez être prudent avec cette fonctionnalité et vous voyez un avertissement dans l’info-bulle. Vous pouvez également voir d’autres avertissements. Le déplacement du pointeur ne peut pas rétablir votre application à un état antérieur de l’application.

4. Appuyez sur F5 pour continuer à exécuter l’application.

   Félicitations pour avoir terminé ce tutoriel !

É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