Tutoriel : Apprendre à déboguer le code C# avec Visual Studio

S’applique à :ouiVisual Studio nonVisual Studio pour Mac nonVisual Studio Code

Cet article présente les fonctionnalités du débogueur Visual Studio dans une procédure pas à pas. Pour un tour d’horizon plus général des fonctionnalités du débogueur, voir Présentation du débogueur. Quand vous déboguez votre application, cela signifie généralement que vous exécutez votre application en y ayant attaché le débogueur. Quand vous faites cela, le débogueur fournit de nombreuses façons de voir ce que fait votre code pendant qu’il s’exécute. Vous pouvez parcourir votre code pas à pas et examiner les valeurs stockées dans les variables, vous pouvez définir des espions sur des variables pour voir quand les valeurs changent, vous pouvez examiner le chemin d’exécution de votre code, voir si une branche de code s’exécute, etc. Si c’est la première fois que vous essayez de déboguer du code, vous pouvez lire Débogage pour les débutants absolus avant de parcourir 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 l’édition et la poursuite. F# et JavaScript ne prennent pas en charge la fenêtre Autos ). Les captures d’écran sont en C#.

Ce didacticiel présente les procédures suivantes :

  • Démarrer le débogueur et atteindre des points d’arrêt
  • Découvrir les commandes permettant de parcourir le code pas à pas 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

Prérequis

Visual Studio 2022 doit être installé et la charge de travail de développement de bureau .NET doit être installée.

Vous devez avoir installé Visual Studio 2019 et la charge de travail de développement multiplateforme .NET Core .

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

Si vous avez besoin d’installer la charge de travail, mais que vous disposez déjà de Visual Studio, accédez à Outils>Obtenir des outils et des fonctionnalités..., ce qui ouvre le Visual Studio Installer. Visual Studio Installer est lancé. Choisissez la charge de travail de développement multiplateforme .NET Core , puis choisissez Modifier.

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

Création d’un projet

Tout d’abord, vous allez créer un projet d’application console .NET Core. Le type de projet inclut tous les fichiers de modèle dont vous aurez besoin au départ.

  1. Ouvrez Visual Studio.

    Si la fenêtre de démarrage n’est pas ouverte, choisissezFenêtre de démarrage de fichier>.

  2. Dans la fenêtre de démarrage, choisissez Créer un projet.

  3. Dans la fenêtre Créer un projet, entrez ou tapez console dans la zone de recherche. Ensuite, choisissez C# Dans la liste des langages, puis choisissez Windows dans la liste des plateformes.

    Après avoir appliqué les filtres de langue et de plateforme, choisissez le modèle Application console pour .NET Core, puis suivant.

    Capture d’écran du modèle C# pour l’application console.

    Remarque

    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 Vous ne trouvez pas ce que vous cherchez ?, choisissez le lien Installer plus d’outils et de fonctionnalités. Ensuite, dans Visual Studio Installer, choisissez la charge de travail Développement multiplateforme .NET Core.

  4. Dans la fenêtre Configurer votre nouveau projet , tapez ou entrez GetStartedDebugging dans la zone Nom du projet . Ensuite, choisissez Suivant.

  5. Choisissez l’infrastructure cible recommandée (.NET Core 3.1 (prise en charge à long terme)) ou .NET 5.0 (actuel), puis choisissez Créer.

    Visual Studio ouvre votre nouveau projet.

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

  2. Dans la fenêtre de démarrage, choisissez Créer un projet.

  3. Dans la fenêtre Créer un projet, entrez ou tapez console dans la zone de recherche. Ensuite, choisissez C# Dans la liste des langages, puis choisissez Windows dans la liste des plateformes.

    Après avoir appliqué les filtres de langue et de plateforme, choisissez le modèle Application console , puis suivant.

    Capture d’écran du modèle « Application console » dans la fenêtre « Créer un projet » de Visual Studio 2022.

    Remarque

    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 Vous ne trouvez pas ce que vous cherchez ?, choisissez le lien Installer plus d’outils et de fonctionnalités. Ensuite, dans le Visual Studio Installer, choisissez la charge de travail de développement de bureau .NET.

  4. Dans la fenêtre Configurer votre nouveau projet , tapez ou entrez GetStartedDebugging dans la zone Nom du projet . Ensuite, choisissez Suivant.

  5. Dans la fenêtre Informations supplémentaires , vérifiez que .NET 6.0 (prise en charge à long terme) est sélectionné dans le menu déroulant Framework , puis choisissez Créer.

    Visual Studio ouvre votre nouveau projet.

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

  1. Appuyez sur F5 (Démarrer le débogage de débogage>) ou sur l’image du bouton Démarrerle débogage du bouton « Démarrer le débogage ». dans la barre d’outils Débogage.

    F5 démarre l’application avec le débogueur attaché au processus de l’application, mais jusqu’à présent, nous n’avons rien fait de spécial pour examiner le code. Par conséquent, l’application se charge simplement et vous verrez cette sortie de 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, nous examinons cette application plus en détail avec le débogueur et nous regardons les fonctionnalités du débogueur.

  2. Arrêtez le débogueur en appuyant sur l’image rouge stop du bouton « Arrêter le débogage ». (Maj + F5).

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

La plupart du temps, nous utilisons des raccourcis clavier ici, car il s’agit d’un moyen rapide d’exécuter des commandes de débogueur. Des commandes équivalentes, telles que des commandes de barre d’outils ou de menu, sont également notées.

  1. 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éboguer, ou choisissez Déboguer>Démarrer le débogage dans la barre de menus.

    Capture d’écran du bouton « Cible de débogage » dans la barre d’outils Standard de Visual Studio 2022.

    F5 démarre l’application avec le débogueur attaché au processus d’application. Étant donné que nous n’avons rien fait de spécial pour examiner le code, l’application s’exécute jusqu’à l’achèvement 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
    
  2. 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.

    Capture d’écran du bouton « Arrêter le débogage » dans la barre d’outils Déboguer de Visual Studio 2022.

  3. Dans la fenêtre de console, sélectionnez n’importe quelle touche pour fermer la fenêtre de console.

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

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

    name += letters[i];

    Cercle rouge Image d’un point d’arrêt. s’affiche à l’emplacement où vous définissez le point d’arrêt.

    Les points d’arrêt sont l’une des fonctionnalités les plus basiques et essentielles du débogage fiable. Quand vous définissez un point d'arrêt, Visual Studio interrompt l'exécution du code à l'emplacement du point d'arrêt pour vous permettre d'examiner les valeurs des variables, le comportement de la mémoire ou encore la bonne exécution ou non d'une branche de code.

  2. Appuyez sur F5 ou sur le bouton Démarrerle débogage Capture d’écran du bouton « Démarrer le débogage »., l’application démarre et le débogueur s’exécute sur la ligne de code où vous définissez le point d’arrêt.

    Définir et atteindre un point d’arrêt

    La flèche jaune représente l’instruction sur laquelle le débogueur s’est mis en pause, ce qui interrompt également l’exécution de l’application au même point (cette instruction n’a pas encore été exécutée).

    Si l’application ne s’exécute pas encore, F5 démarre le débogueur et s’arrête au premier point d’arrêt. Sinon, F5 continue l’exécution de l’application jusqu’au point d’arrêt suivant.

    Les points d’arrêt sont une fonctionnalité pratique quand vous savez quelle ligne de code ou section de code vous voulez 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.

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

    name += letters[i];

    Un cercle rouge apparaît là où vous avez défini le point d’arrêt.

    Capture d’écran d’un point d’arrêt dans Visual Studio 2022.

    Les points d’arrêt sont une fonctionnalité essentielle du débogage fiable. Vous pouvez définir des points d’arrêt où vous souhaitez que Visual Studio interrompe 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 ou non.

  2. Pour démarrer le débogage, sélectionnez F5 ou choisissez le bouton Déboguer la cible dans la barre d’outils Standard, ou choisissez le bouton Démarrer le débogage dans la barre d’outils Déboguer, 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 sur la ligne de code où vous définissez le point d’arrêt.

    Capture d’écran montrant un point d’arrêt dans l’éditeur de code de Visual Studio 2022, avec l’exécution du code suspendue au 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’étant pas encore exécutée.

    Lorsque l’application n’est pas en cours d’exécution, F5 démarre le débogueur, qui l’exécute 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.

Nous utilisons ici principalement des raccourcis clavier, car c’est un bon moyen d’exécuter rapidement votre application dans le débogueur (les commandes équivalentes, comme les commandes des menus, sont indiquées entre parenthèses).

  1. En pause sur l’instruction name += letters[i] , pointez sur la letters variable et vous voyez sa valeur par défaut, la valeur du premier élément du tableau, char[10].

    Les fonctionnalités qui vous permettent d’inspecter des variables sont parmi les plus pratiques du débogueur : vous pouvez faire cela de différentes façons. Souvent, quand vous essayez de déboguer un problème, vous essayez de déterminer si les variables stockent les valeurs que vous prévoyez à un moment donné.

  2. Développez la letters variable pour afficher ses propriétés, qui incluent tous les éléments qu’elle contient.

    Capture d’écran du débogueur suspendu à l’instruction « name+= letters[I] ».

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

  4. Appuyez deux fois sur F10 (ou choisissez Déboguer > pas à pas) pour passer à l’appel SendMessage de méthode, puis appuyez une fois de plus sur F10 .

    F10 fait passer le débogueur à l’instruction suivante 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, nous avons ignoré le code d’implémentation pour SendMessage (qui ne nous intéresse peut-être pas pour le moment).

  5. Appuyez plusieurs fois sur F10 (ou Déboguer>pas à pas) pour itérer plusieurs fois dans la for boucle, en mettant à nouveau en pause au point d’arrêt et en pointant sur la name variable à chaque fois pour vérifier sa valeur.

    Capture d’écran animée du débogueur Visual Studio montrant l’effet d’appuyer sur F10 sur « Pas à pas » et d’itérer dans une boucle pendant le débogage.

    La valeur de la variable change à chaque itération de la for boucle, affichant les valeurs de f, puis fr, puis fre, et ainsi de suite. Pour faire avancer le débogueur dans la boucle plus rapidement dans ce scénario, vous pouvez appuyer sur F5 (ou choisirContinuer le débogage>), ce qui vous fait passer au point d’arrêt au lieu de l’instruction suivante.

    Souvent, lors du débogage, vous voulez un moyen rapide de vérifier les valeurs des propriétés sur des variables pour voir si elles stockent bien les valeurs prévues. Les bulles d’informations (« data tips ») sont un bon moyen de le faire.

  6. Tout en étant toujours suspendu dans la for boucle dans la Main méthode, appuyez sur F11 (ou choisissez Déboguer > Pas à pas) jusqu’à ce que vous arrêtiez à l’appel de méthode SendMessage .

    Vous devez être à cette ligne de code :

    SendMessage(name, a[i]);

  7. Appuyez une fois de plus sur F11 pour entrer dans la SendMessage méthode.

    Le pointeur jaune avance dans la SendMessage méthode.

    Capture d’écran du pointeur d’exécution de la méthode SendMessage.

    F11 est la commande Pas à pas détaillé : elle fait avancer l’exécution de l’application une instruction à la fois. F11 est un bon moyen pour examiner le flux de l’exécution de la façon la plus détaillée. Par défaut, le débogueur ignore le code non-utilisateur (si vous voulez plus d’informations, consultez Uniquement mon code).

    Supposons que vous avez terminé d’examiner la SendMessage méthode et que vous souhaitez sortir de la méthode, mais rester dans le débogueur. Vous pouvez faire cela avec la commande Pas à pas sortant.

  8. Appuyez sur Maj + F11 (ou Déboguer > pas à pas).

    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 être de retour dans la for boucle dans la Main méthode, suspendu à l’appel de SendMessage méthode. Pour plus d’informations sur les différentes façons de parcourir votre code, consultez Naviguer dans le code dans le débogueur.

  1. En pause sur l’instruction name += letters[i] , pointez sur la letters variable pour voir un conseil de données montrant la taille du tableau et le type d’élément, char[10].

    Remarque

    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 essayez de déterminer si les variables ont des valeurs que vous attendez à un moment donné. L’affichage des conseils de données est un bon moyen de vérifier cela.

  2. Développez la letters variable pour afficher tous ses éléments de tableau et leurs valeurs.

    Capture d’écran d’un conseil de données de débogueur dans Visual Studio 2022 qui montre les valeurs d’élément pour la variable de tableau « letters ».

  3. Pointez sur la name variable pour voir sa valeur actuelle, qui est une chaîne vide.

  4. Pour faire passer le débogueur à l’instruction suivante, sélectionnez F10, cliquez sur le bouton Pas à pas dans la barre d’outils Déboguer, ou choisissez Déboguer>Pas à pas dans la barre de menus. Sélectionnez F10 deux fois plus pour passer au-delà de l’appel de SendMessage méthode.

    F10 avance le débogueur sans passer à la fonction ou aux méthodes, bien que leur code s’exécute toujours. De cette façon, nous avons ignoré le débogage du code dans la SendMessage méthode, ce qui ne nous intéresse pas pour le moment.

  5. Pour itérer à travers la for boucle 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 name variable pour vérifier sa valeur dans le conseil de données.

    Capture d’écran d’un conseil de données de débogueur dans Visual Studio 2022 qui montre la valeur de chaîne pour la variable « name ».

    La valeur de la variable change à chaque itération de la for boucle, affichant les valeurs de f, puis fr, puis fre, et ainsi de suite. Pour accélérer le débogueur dans la boucle, sélectionnez plutôt F5 , qui passe à votre point d’arrêt au lieu de l’instruction suivante.

  6. Lorsque vous êtes suspendu dans la for boucle de la Main méthode, sélectionnez F11, ou choisissez le bouton Pas à pas dans la barre d’outils Déboguer, ou choisissez Déboguer>Pas à pas dans la barre de menus, jusqu’à ce que vous atteigniez l’appel de SendMessage méthode.

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

    SendMessage(name, a[i]);

  7. Pour accéder à la SendMessage méthode, sélectionnez À nouveau F11 .

    Le pointeur jaune avance dans la SendMessage méthode.

    Capture d’écran montrant le pointeur d’exécution du débogueur dans la méthode « SendMessage ».

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

    Une fois que vous avez terminé le débogage de la SendMessage méthode, vous êtes prêt à revenir à la for boucle de la main méthode.

  8. Pour quitter la SendMessage méthode, sélectionnez Maj+F11, ou choisissez le bouton Pas à pas dans la barre d’outils Déboguer, ou choisissez Déboguer>pas à pas dans la barre de menus.

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

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

  1. Sélectionnez 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 Exécuter jusqu’à cliquer en vert Image du bouton « Exécuter pour cliquer ». apparaît à gauche. L’info-bulle du bouton indique « Lancer l’exécution jusqu’ici ».

    Capture d’écran du bouton « Exécuter pour cliquer ».

    Remarque

    Le bouton Exécuter pour cliquer est nouveau dans Visual Studio 2017. (Si vous ne voyez pas le bouton de flèche verte, utilisez plutôt F11 dans cet exemple pour faire avancer le débogueur à l’emplacement approprié.)

  3. Cliquez sur le bouton Exécuter pour cliquerImage du bouton « Exécuter pour cliquer »..

    Le débogueur passe à la Console.WriteLine méthode .

    L’utilisation de ce bouton revient à définir un point d’arrêt temporaire. Exécuter jusqu’au clic est pratique pour examiner rapidement une zone visible du code d’application (vous pouvez cliquer dans n’importe quel fichier ouvert).

  1. Sélectionnez F5 pour passer à nouveau au point d’arrêt.

  2. Dans l’éditeur de code, pointez sur l’appel Console.WriteLine de méthode dans la SendMessage méthode jusqu’à ce que le bouton Exécuter en clic s’affiche à gauche. L’info-bulle du bouton indique « Lancer l’exécution jusqu’ici ».

    Capture d’écran montrant le bouton « Exécuter pour cliquer » dans Visual Studio 2022.

  3. Choisissez le bouton Exécuter pour cliquer . Vous pouvez également sélectionner Ctrl+F10 avec votre curseur au niveau de l’instructionConsole.WriteLine. Vous pouvez également cliquer avec le bouton droit sur l’appel Console.WriteLine de méthode, puis choisir Exécuter au curseur dans le menu contextuel.

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

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

Redémarrer rapidement votre application

Cliquez sur l’image redémarrer du bouton « Redémarrer l’application ». dans la barre d’outils Débogage (Ctrl + Maj + F5).

Quand vous appuyez sur Redémarrer, vous gagnez du temps par rapport à l’action consistant à arrêter l’application, puis à redémarrer le débogueur. Le débogueur se met en pause sur le premier point d’arrêt qui est atteint par l’exécution du code.

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

Pour réexécuter votre application depuis le début dans le débogueur, sélectionnez Ctrl+Maj+F5, ou choisissez le bouton Redémarrer dans la barre d’outils Déboguer, ou choisissez>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.

Le redémarrage arrête le débogueur, puis le redémarre, en une seule étape. Lorsque le débogueur redémarre, il s’exécute sur le 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 for boucle, puis s’interrompt.

Inspecter des variables avec les Fenêtres Automatique et Variables locales

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

    S’il est fermé, ouvrez-le en pause dans le débogueur en choisissant Déboguer>Windows>Autos.

    Dans la fenêtre Automatique, vous voyez des variables et leur valeur actuelle. La fenêtre Automatique montre toutes les variables utilisées dans la ligne active ou la ligne précédente (consultez la documentation pour les comportements selon le langage).

  2. Ensuite, examinons la fenêtre Variables locales, sous un onglet à côté de la fenêtre Automatique.

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

    Capture d’écran de la fenêtre Locals dans Visual Studio.

    La fenêtre Variables locales montre les variables qui se trouvent dans l’étendue actuelle, c’est-à-dire le contexte d’exécution actif.

Les fenêtres Autos et Locals affichent les valeurs des variables pendant le débogage. Les fenêtres sont disponibles uniquement pendant une session de débogage. La fenêtre Autos affiche les variables utilisées sur la ligne active à laquelle se trouve 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.

  1. Pendant que 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.

  2. Le débogueur étant toujours en pause, affichez la fenêtre Locals dans un onglet en regard de la fenêtre Autos .

    Si la fenêtre Locals est fermée, sélectionnez Ctrl+D, L ou choisissez Déboguer>les locauxWindows>.

  3. Dans la fenêtre Locals , développez la letters variable pour voir ses éléments de tableau et leurs valeurs.

    Capture d’écran de la fenêtre Locals dans Visual Studio 2022, avec la variable de tableau « lettres » développée.

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

Définir un espion

  1. Dans la fenêtre principale de l’éditeur de code, cliquez avec le bouton droit sur la name variable et choisissez Ajouter une montre.

    La fenêtre Espion s’ouvre en bas de l’éditeur de code. Vous pouvez utiliser une fenêtre Espion pour spécifier une variable (ou une expression) que vous voulez observer.

    Vous disposez maintenant d’une montre définie sur la name variable et vous pouvez voir sa valeur changer lorsque vous parcourez le débogueur. Contrairement à d’autres fenêtres de variables, la fenêtre Espion montre toujours les variables que vous observez (elles apparaissent en grisé quand elles sont en dehors de l’étendue).

Vous pouvez spécifier une variable, ou une expression, sur laquelle 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 veille sur la name variable, parcourez votre code pour voir la valeur de la name variable modifiée à chaque for itération de boucle.

    Contrairement aux autres fenêtres variables, la fenêtre Espion affiche toujours les variables que vous regardez, bien qu’elles soient grisées lorsqu’elles ne sont pas dans l’étendue.

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

Examiner la pile des appels

  1. Alors que l’exécution est mise en pause dans la boucle for, cliquez sur la fenêtre Pile des appels qui est ouverte par défaut dans le volet inférieur droit.

    S’il est fermé, ouvrez-le en pause dans le débogueur en choisissant Déboguer la>pile d’appelsWindows>.

  2. Cliquez plusieurs fois sur F11 jusqu’à ce que vous voyiez la pause du débogueur dans la SendMessage méthode. Regardez la fenêtre Pile des appels.

    Capture d’écran de la fenêtre Pile des appels dans Visual Studio.

    La fenêtre Pile des appels montre l’ordre dans lequel les méthodes et les fonctions sont appelées. La ligne du haut montre la fonction active (méthode SendMessage dans cette application). La deuxième ligne montre que SendMessage a été appelée à partir de la méthode Main, etc.

    Remarque

    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 accéder à ce code source ; ceci 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 et aller examiner le code source. Pour plus d’informations, consultez Guide pratique pour examiner la pile des appels.

La pile d’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.

  1. Pendant que le débogueur est suspendu dans la for boucle, affichez 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> lapile d’appelsWindows> dans la barre de menus.

    Dans la fenêtre Pile des appels , vous verrez le pointeur jaune sur la méthode actuelle Main .

  2. Sélectionnez F11 plusieurs fois jusqu’à ce que vous voyiez la pause du débogueur dans la SendMessage méthode.

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

    Capture d’écran de la fenêtre Pile des appels dans Visual Studio 2022.

    Remarque

    La fenêtre Pile des appels est similaire à la perspective Déboguer 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 modifie l’étendue actuelle 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 à l’aide de Exécuter au curseur ou accéder au code source.

Pour plus d’informations sur la pile des appels, consultez Guide pratique pour examiner la pile des appels.

Changer le flux d’exécution

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

  2. Une fois le débogueur suspendu dans l’appel SendMessage de méthode, utilisez la souris pour saisir la flèche jaune (pointeur d’exécution) à gauche et déplacer la flèche jaune vers le haut d’une ligne, revenir à Console.WriteLine.

  3. Appuyez sur F11.

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

    En changeant le flux d’exécution, vous pouvez effectuer des opérations comme tester d’autres chemins d’exécution du code ou réexécuter du code sans devoir redémarrer le débogueur.

    Avertissement

    Vous devez rester prudent avec cette fonctionnalité, vous pouvez voir un avertissement dans l’info-bulle. Vous pouvez aussi en voir d’autres. Le fait de déplacer le pointeur ne peut pas rétablir votre application à un état antérieur.

  4. Appuyez sur F5 pour poursuivre l’exécution de l’application.

    Félicitations ! Vous avez terminé ce didacticiel.

Vous pouvez déplacer le pointeur d’exécution pour modifier le flux de votre application lors du débogage.

  1. Une fois le débogueur suspendu à l’appel SendMessage de méthode dans la for boucle, sélectionnez F11 trois fois pour entrer dans la SendMessage méthode et passer au-delà de la méthode après l’avoir Console.WriteLine exécutée.

    Le débogueur est maintenant suspendu à l’accolade de fermeture finale de la SendMessage méthode.

  2. Utilisez la souris pour saisir la flèche jaune ou le pointeur d’exécution (dans la marge gauche), puis faites glisser le pointeur vers le haut d’une ligne.

    Le débogueur est maintenant de retour sur l’instruction Console.WriteLine .

  3. Sélectionnez F11.

    Le débogueur réexécutera la Console.WriteLine méthode et vous verrez une ligne dupliquée dans la sortie de la fenêtre de console.

  4. Sélectionnez F5 pour continuer à exécuter l’application.

En changeant le flux d’exécution, vous pouvez effectuer des opérations comme tester d’autres chemins d’exécution du code ou réexécuter du code sans devoir redémarrer le débogueur.

Avertissement

Utilisez cette fonctionnalité avec soin. Vous verrez un avertissement dans l’info-bulle du pointeur d’exécution concernant la possibilité de conséquences involontaires. Vous pouvez également voir d’autres avertissements. Le déplacement du pointeur d’exécution ne peut pas rétablir votre application à un état antérieur.

Pour plus d’informations sur la modification du flux d’exécution, consultez Déplacer le pointeur pour modifier le flux d’exécution.

Félicitations ! Vous avez terminé ce didacticiel.

Étapes suivantes

Dans ce tutoriel, vous avez découvert comment démarrer le débogueur, parcourir le code pas à pas et inspecter des 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.