Didacticiel : Apprenez à déboguer à l’aide de Visual StudioTutorial: Learn to debug using Visual Studio

Cet article présente les fonctionnalités du débogueur Visual Studio dans une procédure pas à pas.This article introduces the features of the Visual Studio debugger in a step-by-step walkthrough. Si vous souhaitez une vue plus générale des fonctionnalités du débogueur, consultez visite guidée des fonctionnalités débogueur.If you want a higher-level view of the debugger features, see Debugger Feature Tour. Lorsque vous déboguer votre application, cela signifie généralement que vous exécutez votre application avec le débogueur attaché.When you debug your app, it usually means that you are running your application with the debugger attached. Lorsque vous effectuez cette opération, le débogueur fournit de nombreuses façons de voir ce que fait votre code pendant son exécution.When you do this, the debugger provides many ways to see what your code is doing while it runs. Vous pouvez parcourir votre code et examinez les valeurs stockées dans des variables, vous pouvez définir des observations sur les variables pour voir quand les valeurs changent, vous pouvez examiner le chemin d’accès de l’exécution de votre code, si une branche de code est en cours d’exécution, et ainsi de suite.You can step through your code and look at the values stored in variables, you can set watches on variables to see when values change, you can examine the execution path of your code, see whether a branch of code is running, and so on. S’il s’agit de la première fois que vous avez essayé de déboguer du code, il pouvez que vous souhaitez lire débogage pour les débutants avant de poursuivre cet article.If this is the first time that you've tried to debug code, you may want to read Debugging for absolute beginners before going through this article.

Icône représentant une caméra pour les vidéosmovie camera icon for video Regardez une vidéo sur le débogage, qui affiche des étapes similaires.Watch a video on debugging that shows similar steps.

Bien que l’application de démonstration est c# et C++, les fonctionnalités sont applicables à Visual Basic, JavaScript et d’autres langages pris en charge par Visual Studio (sauf indication contraire).Although the demo app is C# and C++, the features are applicable to Visual Basic, JavaScript, and other languages supported by Visual Studio (except where noted). Les captures d’écran sont en c#.The screenshots are in C#. Pour basculer entre le code c# et C++ exemple dans cet article, utilisez le filtre de langage dans le coin supérieur droit de cette page.To switch between the C# and C++ sample code in this article, use the language filter in the upper right of this page.

Dans ce didacticiel, vous allez effectuer les actions suivantes :In this tutorial, you will:

  • Démarrez le débogueur et les points d’arrêt.Start the debugger and hit breakpoints.
  • Découvrez les commandes pour parcourir le code dans le débogueurLearn commands to step through code in the debugger
  • Inspecter des variables dans des bulles d’informations et les fenêtres du débogueurInspect variables in data tips and debugger windows
  • Examiner la pile des appelsExamine the call stack

PrérequisPrerequisites

  • Vous devez disposer de Visual Studio 2017 est installé et le développement .NET desktop ou développement Desktop en C++ charge de travail.You must have Visual Studio 2017 installed and the .NET desktop development or Desktop development with C++ workload.

    Si vous n’avez pas encore installé Visual Studio, accédez à la page Téléchargements Visual Studio pour l’installer gratuitement.If you haven't already installed Visual Studio, go to the Visual Studio downloads page to install it for free.

    Si vous devez installer la charge de travail mais que vous avez déjà Visual Studio, cliquez sur le lien Ouvrir Visual Studio Installer dans le volet gauche de la boîte de dialogue Nouveau projet (sélectionnez Fichier > Nouveau > Projet).If you need to install the workload but already have Visual Studio, click the Open Visual Studio Installer link in the left pane of the New Project dialog box (select File > New > Project). Visual Studio Installer est lancé.The Visual Studio Installer launches. Choisissez le. Développement bureautique NET ou développement Desktop en C++ charge de travail, puis choisissez modifier.Choose the .NET desktop development or Desktop development with C++ workload, then choose Modify.

Créer un projetCreate a project

  1. Dans Visual Studio, sélectionnez Fichier > Nouveau projet.In Visual Studio, choose File > New Project.

  2. Sous Visual C# ou Visual C++, choisissez Windows Desktop, puis, dans le volet central, choisissez application Console ( Application de Console Windows en C++).Under Visual C# or Visual C++, choose Windows Desktop, and then in the middle pane choose Console App (Windows Console Application in C++).

    Si vous ne voyez pas le Application Console modèle de projet, cliquez sur le ouvrir Visual Studio Installer lien dans le volet gauche de la nouveau projet boîte de dialogue.If you don't see the Console Application project template, click the Open Visual Studio Installer link in the left pane of the New Project dialog box. Visual Studio Installer est lancé.The Visual Studio Installer launches. Choisissez le développement .NET desktop* ou développement Desktop en C++ charge de travail, puis choisissez modifier.Choose the .NET desktop development* or Desktop development with C++ workload, then choose Modify.

  3. Tapez un nom tel que get-démarré-débogage et cliquez sur OK.Type a name like get-started-debugging and click OK.

    Visual Studio crée le projet.Visual Studio creates the project.

  4. Dans Program.cs (c#) ou get-démarré-debugging.cpp (C++), remplacez le code suivantIn Program.cs (C#) or get-started-debugging.cpp (C++), replace the following code

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace get_started_debugging
    {
        class Program
        {
            static void Main(string[] args)
            {
            }
        }
    }
    
    int main()
    {
        return 0;
    }
    

    par le code suivant :with this code:

    using System;
    using System.Collections.Generic;
    
    public class Shape
    {
        // A few example members
        public int X { get; private set; }
        public int Y { get; private set; }
        public int Height { get; set; }
        public int Width { get; set; }
    
        // Virtual method
        public virtual void Draw()
        {
            Console.WriteLine("Performing base class drawing tasks");
        }
    }
    
    class Circle : Shape
    {
        public override void Draw()
        {
            // Code to draw a circle...
            Console.WriteLine("Drawing a circle");
            base.Draw();
        }
    }
    
    class Rectangle : Shape
    {
        public override void Draw()
        {
            // Code to draw a rectangle...
            Console.WriteLine("Drawing a rectangle");
            base.Draw();
        }
    }
    
    class Triangle : Shape
    {
        public override void Draw()
        {
            // Code to draw a triangle...
            Console.WriteLine("Drawing a trangle");
            base.Draw();
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
    
            var shapes = new List<Shape>
            {
                new Rectangle(),
                new Triangle(),
                new Circle()
            };
    
            foreach (var shape in shapes)
            {
                shape.Draw();
            }
    
            // Keep the console open in debug mode.
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    
    }
    
    /* Output:
        Drawing a rectangle
        Performing base class drawing tasks
        Drawing a triangle
        Performing base class drawing tasks
        Drawing a circle
        Performing base class drawing tasks
    */
    
    #include "pch.h"
    
    #include <string>
    #include <vector>
    #include <iostream>
    
    class Shape
    {
        int privateX = 0;
        int privateY = 0;
        int privateHeight = 0;
        int privateWidth = 0;
    
        int getX() const { return privateX; }
        void setX(int value) { privateX = value; }
    
        int getY() const { return privateY; }
        void setY(int value) { privateY = value; }
    
        int getHeight() const { return privateHeight; }
        void setHeight(int value) { privateHeight = value; }
    
        int getWidth() const { return privateWidth; }
        void setWidth(int value) { privateWidth = value; }
    
        public:
        // Virtual method
        virtual void Draw()
        {
            std::wcout << L"Performing base class drawing tasks" << std::endl;
        }
    };
    
    class Circle : public Shape
    {
        public:
        void Draw() override
        {
        // Code to draw a circle...
        std::wcout << L"Drawing a circle" << std::endl;
        Shape::Draw();
        }
    };
    
    class Rectangle : public Shape
    {
        public:
        void Draw() override
        {
        // Code to draw a rectangle...
        std::wcout << L"Drawing a rectangle" << std::endl;
        Shape::Draw();
        }
    };
    
    class Triangle : public Shape
    {
        public:
        void Draw() override
        {
        // Code to draw a triangle...
        std::wcout << L"Drawing a trangle" << std::endl;
        Shape::Draw();
        }
    };
    
    int main(std::vector<std::wstring> &args)
    {
        auto shapes = std::vector<Shape*>
        {
            new Rectangle(),
            new Triangle(),
            new Circle()
        };
    
        for (auto shape : shapes)
        {
            shape->Draw();
        }
    }
    
    /* Output:
    Drawing a rectangle
    Performing base class drawing tasks
    Drawing a triangle
    Performing base class drawing tasks
    Drawing a circle
    Performing base class drawing tasks
    */
    

Démarrez le débogueur !Start the debugger!

  1. Appuyez sur F5 (Déboguer > Démarrer le débogage) ou le démarrer le débogage bouton démarrer le débogage dans la barre d’outils de débogage.Press F5 (Debug > Start Debugging) or the Start Debugging button Start Debugging in the Debug Toolbar.

    F5 démarre l’application avec le débogueur est attachée à l’application traiter, mais actuellement, nous n’avons pas fait rien de spécial à examiner le code.F5 starts the app with the debugger attached to the app process, but right now we haven't done anything special to examine the code. Par conséquent, l’application se charge juste et vous voyez la sortie de console.So the app just loads and you see the console output.

    Drawing a rectangle
    Performing base class drawing tasks
    Drawing a triangle
    Performing base class drawing tasks
    Drawing a circle
    Performing base class drawing tasks
    

    Dans ce didacticiel, nous examinons plus en détail cette application à l’aide du débogueur et avoir une idée du débogueur de fonctionnalités.In this tutorial, we'll take a closer look at this app using the debugger and get a look at the debugger features.

  2. Arrêtez le débogueur en appuyant sur le taquet rouge arrêter le débogage bouton.Stop the debugger by pressing the red stop Stop Debugging button.

Définissez un point d’arrêt et démarrez le débogueurSet a breakpoint and start the debugger

  1. Dans le foreach boucle de la Main (fonction) (for boucle en C++ main fonction), définissez un point d’arrêt en cliquant sur la marge gauche de la ligne de code suivante :In the foreach loop of the Main function (for loop in C++ main function), set a breakpoint by clicking the left margin of the following line of code:

    shape.Draw() (ou, shape->Draw() dans C++)shape.Draw() (or, shape->Draw() in C++)

    Un cercle rouge s’affiche où vous avez défini le point d’arrêt.A red circle appears where you set the breakpoint.

    Les points d'arrêt constituent une fonctionnalité élémentaire et essentielle de toute procédure de débogage fiable.Breakpoints are the most basic and essential feature of reliable debugging. 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.A breakpoint indicates where Visual Studio should suspend your running code so you can take a look at the values of variables, or the behavior of memory, or whether or not a branch of code is getting run.

  2. Appuyez sur F5 ou démarrer le débogage bouton, l’application démarre, et le débogueur exécute jusqu'à la ligne de code où vous avez défini le point d’arrêt.Press F5 or the Start Debugging button, the app starts, and the debugger runs to the line of code where you set the breakpoint.

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

    La flèche jaune représente l’instruction sur laquelle le débogueur a suspendu, ce qui interrompt également l’exécution d’application au même moment (cette instruction n’a pas encore exécuté).The yellow arrow represents the statement on which the debugger paused, which also suspends app execution at the same point (this statement has not yet executed).

    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.If the app is not yet running, F5 starts the debugger and stops at the first breakpoint. Sinon, F5 continue l’exécution de l’application au point d’arrêt suivant.Otherwise, F5 continues running the app to the next breakpoint.

    Les points d’arrêt sont une fonctionnalité utile quand vous savez quelle ligne ou section de code vous voulez examiner en détail.Breakpoints are a useful feature when you know the line of code or the section of code that you want to examine in detail.

Principalement, nous utilisons ici, des raccourcis clavier, car c’est un bon moyen pour obtenir rapidement à l’exécution de votre application dans le débogueur (commandes équivalentes tels que menu commandes sont affichées entre parenthèses).Mostly, we use the keyboard shortcuts here, because it's a good way to get fast at executing your app in the debugger (equivalent commands such as menu commands are shown in parentheses).

  1. Pendant la suspension dans le shape.Draw appel de méthode dans le Main (méthode) (shape->Draw en C++), appuyez sur F11 (ou choisissez Déboguer > pas à pas détaillé) pour faire avancer dans le code pour le Rectangle classe.While paused in the shape.Draw method call in the Main method (shape->Draw in C++), press F11 (or choose Debug > Step Into) to advance into code for the Rectangle class.

    Utilisez F11 pour le code pas à pas détailléUse F11 to Step Into code

    F11 est la commande pas à pas détaillé et elle exécute l'application une instruction à la fois.F11 is the Step Into command and advances the app execution one statement at a time. F11 est une bonne solution pour examiner le flux d’exécution en détails.F11 is a good way to examine the execution flow in the most detail. (Pour déplacer plus rapidement le code, nous vous montrons d’autres options également.) Par défaut, le débogueur ignore le code non-utilisateur (si vous souhaitez plus d’informations, consultez uniquement mon Code).(To move faster through code, we show you some other options also.) By default, the debugger skips over non-user code (if you want more details, see Just My Code).

  2. Appuyez sur F10 (ou choisissez Déboguer > pas à pas principal) plusieurs fois jusqu'à ce que le débogueur s’arrête sur la base.Draw appel de méthode (Shape::Draw en C++), puis appuyez sur F10 Encore une fois.Press F10 (or choose Debug > Step Over) a few times until the debugger stops on the base.Draw method call (Shape::Draw in C++), and then press F10 one more time.

    Utiliser la touche F10 pour le code pas à pas principalUse F10 to Step Over code

    Notez que cette fois que le débogueur ne parcourt pas le Draw méthode de la classe de base (Shape).Notice this time that the debugger does not step into the Draw method of the base class (Shape). F10 fait avancer le débogueur sans entrer dans les fonctions ou méthodes dans votre code d’application (le code s’exécute toujours).F10 advances the debugger without stepping into functions or methods in your app code (the code still executes). En appuyant sur F10 le base.Draw (ou Shape::Draw) appel de méthode (au lieu de F11), nous avons ignoré sur le code d’implémentation pour base.Draw (qui nous n’allons pas maintenant intéressés par exemple).By pressing F10 on the base.Draw (or Shape::Draw) method call (instead of F11), we skipped over the implementation code for base.Draw (which maybe we're not interested in right now).

  1. Dans l’éditeur de code, faites défiler vers le bas et placez le curseur sur le Console.WriteLine (méthode) (std::cout en C++) dans le Triangle classe jusqu'à ce que le vert exécuter jusqu’au clic bouton exécuter jusqu’au clic apparaît à gauche.In the code editor, scroll down and hover over the Console.WriteLine method (std::cout in C++) in the Triangle class until the green Run to Click button Run to Click appears on the left.

    Utiliser l’exécution sur clic fonctionnalitéUse the Run to Click feature

    Note

    Le exécuter jusqu’au clic bouton est une nouveauté de Visual Studio 2017Visual Studio 2017.The Run to Click button is new in Visual Studio 2017Visual Studio 2017. Si vous ne voyez pas le bouton fléché vert, utilisez F11 dans cet exemple à la place pour faire avancer le débogueur au bon endroit.If you don't see the green arrow button, use F11 in this example instead to advance the debugger to the right place.

  2. Cliquez sur le exécuter jusqu’au clic bouton exécuter jusqu’au clic.Click the Run to Click button Run to Click.

    L’utilisation de ce bouton est similaire à la définition d’un point d’arrêt temporaire.Using this button is similar to setting a temporary breakpoint. Exécuter jusqu’au clic est pratique pour la navigation rapidement dans une zone visible du code d’application (vous pouvez cliquer dans n’importe quel fichier ouvrir).Run to Click is handy for getting around quickly within a visible region of app code (you can click in any open file).

    Le débogueur avance à la Console.WriteLine implémentation de méthode pour le Triangle classe (std::cout dans C++).The debugger advances to the Console.WriteLine method implementation for the Triangle class (std::cout in C++).

    Pendant la suspension, vous remarquez une faute de frappe !While paused, you notice a typo! La sortie « Dessin un trangle » est mal orthographiée.The output "Drawing a trangle" is misspelled. Nous pouvons corriger ici lors de l’exécution de l’application dans le débogueur.We can fix it right here while running the app in the debugger.

Modifier le code et continuer le débogageEdit code and continue debugging

  1. Cliquez sur « Dessin un trangle » et tapez une correction, en remplaçant « trangle » par « triangle ».Click into "Drawing a trangle" and type a correction, changing "trangle" to "triangle".

  2. Appuyez sur F11 une seule fois et que vous consultez que le débogueur avance à nouveau.Press F11 once and you see that the debugger advances again.

    Note

    Selon le type de code que vous modifiez dans le débogueur, vous pouvez voir un message d’avertissement.Depending on what type of code you edit in the debugger, you may see a warning message. Dans certains scénarios, le code devra recompiler avant de continuer.In some scenarios, the code will need to recompile before you can continue.

Pas à pas sortantStep out

Supposons que vous avez terminé examinant le Draw méthode dans la Triangle classe et que vous souhaitez tirer parti de la fonction, mais restent dans le débogueur.Let's say that you are done examining the Draw method in the Triangle class, and you want to get out of the function but stay in the debugger. Vous pouvez le faire à l’aide de la pas à pas sortant commande.You can do this using the Step Out command.

  1. Appuyez sur MAJ + F11 (ou Déboguer > pas à pas sortant).Press Shift + F11 (or Debug > Step Out).

    Cette commande reprend l’exécution d’application (et avance le débogueur) jusqu'à ce que retourne la fonction active.This command resumes app execution (and advances the debugger) until the current function returns.

    Vous devez être revenu à la foreach boucle dans le Main (méthode) (for boucle en C++).You should be back in the foreach loop in the Main method (for loop in C++).

Redémarrez votre application rapidementRestart your app quickly

Cliquez sur le redémarrer redémarrer une application bouton dans la barre d’outils déboguer (Ctrl + MAJ + F5).Click the Restart Restart App button in the Debug Toolbar (Ctrl + Shift + F5).

Quand vous appuyez sur redémarrer, il fait gagner du temps par rapport à l’arrêt de l’application et de redémarrer le débogueur.When you press Restart, it saves time versus stopping the app and restarting the debugger. Le débogueur s’arrête sur le premier point d’arrêt est atteint par l’exécution de code.The debugger pauses at the first breakpoint that is hit by executing code.

Le débogueur s’arrête à nouveau sur le point d’arrêt que vous définissez, sur le shape.Draw() (méthode) (shape->Draw() en C++).The debugger stops again at the breakpoint you set, on the shape.Draw() method (shape->Draw() in C++).

Inspecter des variables avec des bulles d’informationsInspect variables with data tips

Les fonctionnalités qui vous permettent d’inspecter les variables sont une des fonctionnalités plus utiles du débogueur, et il existe différentes manières de procéder.Features that allow you to inspect variables are one of the most useful features of the debugger, and there are different ways to do it. Souvent, lorsque vous essayez de déboguer un problème, vous essayez de déterminer si les variables sont stocker les valeurs que vous attendez d’avoir à un moment donné.Often, when you try to debug an issue, you are attempting to find out whether variables are storing the values that you expect them to have at a particular time.

  1. Pendant la suspension sur la shape.Draw() (méthode) (shape->Draw() en C++), placez le curseur sur le shapes objet et que vous consultez sa valeur de propriété par défaut, le Count propriété.While paused on the shape.Draw() method (shape->Draw() in C++), hover over the shapes object and you see its default property value, the Count property.

  2. Développez le shapes objet pour voir toutes ses propriétés, telles que le premier index du tableau [0], qui a la valeur de Rectangle (c#) ou une adresse mémoire (C++).Expand the shapes object to see all its properties, such as the first index of the array [0], which has a value of Rectangle (C#) or a memory address (C++).

    Afficher une bulleView a data tip

    Vous pouvez développer davantage les objets pour afficher leurs propriétés, telles que le Height propriété du rectangle.You can further expand objects to view their properties, such as the Height property of the rectangle.

    Souvent, lors du débogage, vous souhaitez un moyen rapide de vérifier les valeurs de propriété sur les objets et les conseils de données constituent un bon moyen de le faire.Often, when debugging, you want a quick way to check property values on objects, and the data tips are a good way to do it.

Inspecter des variables avec les fenêtres automatique et variables localesInspect variables with the Autos and Locals windows

  1. Examinez le automatique fenêtre en bas de l’éditeur de code.Look at the Autos window at the bottom of the code editor.

    Inspecter des variables dans la fenêtre automatiqueInspect variables in the Autos Window

    Dans le automatique fenêtre, vous voyez des variables et leur valeur actuelle.In the Autos window, you see variables and their current value. Le automatique fenêtre affiche toutes les variables utilisées dans la ligne actuelle ou de la ligne précédente (en C++, la fenêtre affiche les variables dans les trois lignes de code précédents.The Autos window shows all variables used on the current line or the preceding line (In C++, the window shows variables in the preceding three lines of code. Consultez la documentation pour le comportement spécifique à la langue).Check documentation for language-specific behavior).

    Note

    Dans JavaScript, le variables locales fenêtre est pris en charge, mais pas le automatique fenêtre.In JavaScript, the Locals window is supported but not the Autos window.

  2. Ensuite, examinons le variables locales fenêtre, dans un onglet à côté du automatique fenêtre.Next, look at the Locals window, in a tab next to the Autos window.

    Le variables locales fenêtre vous montre les variables qui sont en cours étendue.The Locals window shows you the variables that are in the current scope.

Définir un espionSet a watch

  1. Dans la fenêtre d’éditeur de code principal, cliquez sur le shapes de l’objet et choisissez ajouter un espion.In the main code editor window, right-click the shapes object and choose Add Watch.

    Le espion fenêtre s’ouvre au bas de l’éditeur de code.The Watch window opens at the bottom of the code editor. Vous pouvez utiliser un espion fenêtre pour spécifier une variable (ou une expression) que vous souhaitez garder un œil sur.You can use a Watch window to specify a variable (or an expression) that you want to keep an eye on.

    À présent, vous avez un espion défini sur le shapes objet et vous pouvez voir sa valeur changent à mesure que vous parcourez le débogueur.Now, you have a watch set on the shapes object, and you can see its value change as you move through the debugger. Contrairement à d’autres fenêtres de variables, le espion fenêtre affiche toujours les variables que vous surveillez (elles sont grisées lorsque hors de portée).Unlike the other variable windows, the Watch window always shows the variables that you are watching (they're grayed out when out of scope).

Examiner la pile des appelsExamine the call stack

  1. Pendant la suspension dans le foreach boucle (for boucle en C++), cliquez sur le pile des appels fenêtre, qui est par défaut ouvert dans le volet inférieur droit.While paused in the foreach loop (for loop in C++), click the Call Stack window, which is by default open in the lower right pane.

  2. Cliquez sur F11 plusieurs fois jusqu'à ce que vous voyiez le débogueur suspendre dans le Circle.Draw méthode dans l’éditeur de code.Click F11 a few times until you see the debugger pause in the Circle.Draw method in the code editor. Examinez le pile des appels fenêtre.Look at the Call Stack window.

    Examiner la pile des appelsExamine the call stack

    Le pile des appels fenêtre indique l’ordre dans lequel les méthodes et les fonctions sont bien appelées.The Call Stack window shows the order in which methods and functions are getting called. La première ligne affiche la fonction active (la Circle.Draw ou Circle::Draw méthode dans cette application).The top line shows the current function (the Circle.Draw or Circle::Draw method in this app). La deuxième ligne montre que Circle.Draw a été appelée à partir de la Main (méthode) (main en C++), et ainsi de suite.The second line shows that Circle.Draw was called from the Main method (main in C++), and so on.

    Note

    Le pile des appels est identique à la perspective de débogage dans certains IDE comme Eclipse.The Call Stack window is similar to the Debug perspective in some IDEs like Eclipse.

    La pile des appels est un bon moyen d’examiner et de comprendre le flux d’exécution d’une application.The call stack is a good way to examine and understand the execution flow of an app.

    Vous pouvez double-cliquer sur une ligne de code revenir sur ce code source et qui modifie également la portée actuelle est inspectée par le débogueur.You can double-click a line of code to go look at that source code and that also changes the current scope being inspected by the debugger. Cette action n’avance pas le débogueur.This action does not advance the debugger.

    Vous pouvez également utiliser les menus contextuels à partir de la pile des appels fenêtre pour faire autre chose.You can also use right-click menus from the Call Stack window to do other things. Par exemple, vous pouvez insérer des points d’arrêt dans les fonctions spécifiées, faire avancer le débogueur à l’aide de exécuter jusqu’au curseuret accédez à examiner le code source.For example, you can insert breakpoints into specified functions, advance the debugger using Run to Cursor, and go examine source code. Pour plus d’informations, consultez Comment : examiner la pile des appels.For more information, see How to: Examine the Call Stack.

Modifier le flux d’exécutionChange the execution flow

  1. Avec le débogueur en pause dans le Circle.Draw appel de méthode, appuyez sur F11 plusieurs fois jusqu'à ce que le débogueur s’arrête à la base.Draw appel de méthode (Shape::Draw en C++).With the debugger paused in the Circle.Draw method call, press F11 a few times until the debugger pauses on the base.Draw method call (Shape::Draw in C++).

  2. Utilisez la souris pour sélectionner la flèche jaune (le pointeur d’exécution) sur la gauche et déplacer la flèche jaune une ligne à la Console.WriteLine (std::cout en C++) appel de méthode.Use the mouse to grab the yellow arrow (the execution pointer) on the left and move the yellow arrow up one line to the Console.WriteLine (std::cout in C++) method call.

  3. Appuyez sur F11 une nouvelle fois.Press F11 one more time.

    Le débogueur réexécute la Console.WriteLine (méthode) (std::cout en C++).The debugger reruns the Console.WriteLine method (std::cout in C++).

    En modifiant le flux d’exécution, vous pouvez effectuer des opérations telles que les chemins d’exécution de code différent de test ou de réexécuter le code sans avoir à redémarrer le débogueur.By changing the execution flow, you can do things like test different code execution paths or rerun code without restarting the debugger.

    Warning

    Souvent, vous devez être prudent avec cette fonctionnalité, et un avertissement s’affiche dans l’info-bulle.Often you need to be careful with this feature, and you see a warning in the tooltip. Vous pouvez voir les autres avertissements, trop.You may see other warnings, too. Déplacer le pointeur ne peut pas rétablir votre application à un état antérieur de l’application.Moving the pointer cannot revert your application to an earlier app state.

  4. Appuyez sur F5 pour continuer l’exécution de l’application.Press F5 to continue running the app.

    Félicitations ! Vous avez terminé ce didacticiel.Congratulations on completing this tutorial!

Étapes suivantesNext steps

Dans ce didacticiel, vous avez appris comment démarrer le débogueur, parcourir le code et inspecter les variables.In this tutorial, you've learned how to start the debugger, step through code, and inspect variables. Voulez-vous obtenir une vue d’ensemble des fonctionnalités de débogueur ainsi que des liens vers d’autres informations.You may want to get a high-level look at debugger features along with links to more information.