Regardez des variables avec les fenêtres Espion et Espion expressWatch variables with Watch windows and QuickWatch

Pendant le débogage, vous pouvez utiliser espion windows et Espion express pour observer les variables et expressions.While you're debugging, you can use Watch windows and QuickWatch to watch variables and expressions. Les fenêtres sont disponibles uniquement pendant une session de débogage.The windows are only available during a debugging session.

Espion windows peuvent afficher plusieurs variables à la fois pendant le débogage.Watch windows can display several variables at a time while debugging. Le Espion express boîte de dialogue affiche une seule variable à la fois et doit être fermé pour que le débogage puisse se poursuivre.The QuickWatch dialog displays a single variable at a time, and must be closed before debugging can continue.

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 et techniques et des outils de débogage 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 and Debugging techniques and tools before going through this article.

Observer variables dans une fenêtre EspionObserve variables with a Watch window

Vous pouvez ouvrir plusieurs espion fenêtre et observer plusieurs variables dans une espion fenêtre.You can open more than one Watch window, and observe more than one variable in a Watch window.

Par exemple, pour définir un espion sur les valeurs de a, b, et c dans le code suivant :For example, to set a watch on the values of a, b, and c in the following code:

int main()
{
    int a, b, c;
    a = 1;
    b = 2;
    c = 0;

    for (int i = 0; i < 10; i++)
    {
        a++;
        b *= 2;
        c = a + b;
    }

    return 0;
}

  1. Définir un point d’arrêt sur la c = a + b; ligne en cliquant dans la marge de gauche, en sélectionnant déboguer > point d’arrêt, ou en appuyant sur F9.Set a breakpoint on the c = a + b; line by clicking in the left margin, selecting Debug > Toggle Breakpoint, or pressing F9.

  2. Démarrer le débogage en sélectionnant le vert Démarrer flèche ou déboguer > démarrer le débogage, ou appuyez sur F5.Start debugging by selecting the green Start arrow or Debug > Start Debugging, or press F5. L’exécution s’arrête au point d’arrêt.Execution pauses at the breakpoint.

  3. Ouvrir un espion en sélectionnant déboguer > Windows > espion > Espion 1, ou en appuyant sur Ctrl+Alt+W > 1.Open a Watch window by selecting Debug > Windows > Watch > Watch 1, or pressing Ctrl+Alt+W > 1.

    Vous pouvez ouvrir supplémentaires espion windows en sélectionnant windows 2, 3, ou 4.You can open additional Watch windows by selecting windows 2, 3, or 4.

  4. Dans le espion fenêtre, sélectionnez une ligne vide et variable de type a.In the Watch window, select an empty row, and type variable a. Faites de même pour b et c.Do the same for b and c.

    Regardez les variablesWatch variables

  5. Continuer le débogage en sélectionnant déboguer > pas à pas détaillé ou en appuyant sur F11 en fonction des besoins pour faire avancer.Continue debugging by selecting Debug > Step Into or pressing F11 as needed to advance. Les valeurs des variables dans le espion fenêtre Modifier pendant que vous parcourez le for boucle.The variable values in the Watch window change as you iterate through the for loop.

Note

Pour C++ uniquement,For C++ only,

  • Vous devrez peut-être qualifier le contexte d’un nom de variable ou une expression qui utilise un nom de variable.You may need to qualify the context of a variable name, or an expression that uses a variable name. Le contexte est la fonction, le fichier source ou le module où se trouve une variable.The context is the function, source file, or module where a variable is located. Si vous devez qualifier le contexte, utilisez le opérateur de contexte (C++) syntaxe dans le nom dans le espion fenêtre.If you have to qualify the context, use the context operator (C++) syntax in the Name in the Watch window.

  • Vous pouvez ajouter des noms de registres et des noms de variables à l’aide de $ <inscrire nom > ou @ <inscrire nom > à la nom dans le espion fenêtre.You can add register names and variable names using $<register name> or @<register name> to the Name in the Watch window. Pour plus d’informations, consultez Pseudovariables.For more information, see Pseudovariables.

Utiliser des expressions dans une fenêtre EspionUse expressions in a Watch window

Vous pouvez observer toute expression valide reconnue par le débogueur dans un espion fenêtre.You can observe any valid expression recognized by the debugger in a Watch window.

Par exemple, pour le code dans la section précédente, vous pouvez obtenir la moyenne des trois valeurs en entrant (a + b + c) / 3 dans le espion fenêtre :For example, for the code in the preceding section, you can get the average of the three values by entering (a + b + c) / 3 in the Watch window:

Expression espionneWatch expression

Les règles d’évaluation des expressions dans le espion fenêtre sont généralement les mêmes que les règles d’évaluation des expressions dans le langage de code.The rules for evaluating expressions in the Watch window are generally the same as the rules for evaluating expressions in the code language. Si une expression a une erreur de syntaxe, attendez-vous à la même erreur de compilateur, comme dans l’éditeur de code.If an expression has a syntax error, expect the same compiler error as in the code editor. Par exemple, une faute de frappe dans l’expression précédente génère cette erreur dans le espion fenêtre :For example, a typo in the preceding expression produces this error in the Watch window:

Regardez l’erreur d’expressionWatch expression error

Un cercle avec une icône de deux lignes ondulées peut-être apparaître dans le espion fenêtre.A circle with two wavy lines icon may appear in the Watch window. Cette icône signifie que le débogueur n’évalue l’expression en raison d’une dépendance inter-threads potentielle.This icon means the debugger doesn't evaluate the expression because of a potential cross-thread dependency. L’évaluation du code nécessite des autres threads dans votre application pour s’exécuter temporairement, mais étant donné que vous êtes en mode arrêt, tous les threads dans votre application sont généralement arrêtés.Evaluating the code requires other threads in your app to run temporarily, but since you are in break mode, all threads in your app are usually stopped. Permettre à d’autres threads de s’exécuter temporairement peut avoir des effets inattendus sur l’état de votre application et le débogueur peuvent ignorer certains événements tels que des points d’arrêt et des exceptions sur ces threads.Allowing other threads to run temporarily can have unexpected effects on the state of your app, and the debugger may ignore events such as breakpoints and exceptions on those threads.

Rechercher dans la fenêtre EspionSearch in the Watch window

Vous pouvez rechercher des mots clés dans les colonnes Nom, valeur et Type de la espion fenêtre à l’aide de la barre de recherche au-dessus de chaque fenêtre.You can search for keywords in the Name, Value, and Type columns of the Watch window using the search bar above each window. Appuyez sur entrée ou sélectionnez une des flèches pour exécuter une recherche.Hit ENTER or select one of the arrows to execute a search. Pour annuler une recherche en cours, sélectionnez l’icône « x » dans la barre de recherche.To cancel an ongoing search, select the "x" icon in the search bar.

Utilisez les flèches gauche et droite (MAJ + F3 et F3, respectivement) pour naviguer entre trouvé des correspondances.Use the left and right arrows (Shift+F3 and F3, respectively) to navigate between found matches.

Recherche dans la fenêtre EspionSearch in Watch Window

Pour rendre votre recherche plus ou moins complète, utilisez la recherche approfondie liste déroulante en haut de la espion fenêtre pour sélectionner le nombre de niveaux que vous souhaitez rechercher dans imbriqué des objets.To make your search more or less thorough, use the Search Deeper dropdown at the top of the Watch window to select how many levels deep you want to search into nested objects.

Actualiser les valeurs des espionsRefresh watch values

Une icône d’actualisation (flèche circulaire) peut apparaître dans le espion fenêtre lorsqu’une expression est évaluée.A refresh icon (circular arrow) might appear in the Watch window when an expression is evaluated. L’icône de rafraîchissement indique une erreur ou une valeur qui est obsolète.The refresh icon indicates an error or a value that is out of date.

Pour actualiser la valeur, sélectionnez l’icône d’actualisation, ou appuyez sur la barre d’espace.To refresh the value, select the refresh icon, or press the spacebar. Le débogueur essaie de réévaluer l'expression.The debugger tries to reevaluate the expression. Toutefois, vous ne pouvez pas choix ou être en mesure de réévaluer l’expression, en fonction de la raison pour laquelle la valeur n’a pas été évaluée.However, you may not want or be able to reevaluate the expression, depending on why the value wasn't evaluated.

Placez le curseur sur l’icône d’actualisation ou consultez le valeur colonne pour la raison pour laquelle l’expression n’a pas été évaluée.Hover over the refresh icon or see the Value column for the reason the expression wasn't evaluated. Raisons possibles :Reasons include:

  • Une erreur s’est produite car l’expression a été évaluée, comme dans l’exemple précédent.An error occurred as the expression was being evaluated, as in the previous example. Un délai d’expiration peut se produire, ou une variable peut être hors de portée.A timeout might occur, or a variable might be out of scope.

  • L’expression a un appel de fonction qui peut déclencher un effet secondaire dans l’application.The expression has a function call that could trigger a side effect in the app. Consultez Expression effets.See Expression side effects.

  • L’évaluation automatique des propriétés et appels de fonction implicite est désactivée.Automatic evaluation of properties and implicit function calls is disabled.

Si l’icône d’actualisation s’affiche, car l’évaluation automatique des propriétés et appels de fonction implicite est désactivée, vous pouvez l’activer en sélectionnant activer l’évaluation de la propriété et d’autres appels de fonction implicite dans outils > Options > débogage > général.If the refresh icon appears because automatic evaluation of properties and implicit function calls is disabled, you can enable it by selecting Enable property evaluation and other implicit function calls in Tools > Options > Debugging > General.

Pour illustrer l’utilisation de l’icône d’actualisation :To demonstrate using the refresh icon:

  1. Dans outils > Options > débogage > général, désactivez le Activer l’évaluation de la propriété et d’autres appels de fonction implicite case à cocher.In Tools > Options > Debugging > General, clear the Enable property evaluation and other implicit function calls check box.

  2. Entrez le code suivant, puis, dans le espion fenêtre, définissez un espion sur le list.Count propriété.Enter the following code, and in the Watch window, set a watch on the list.Count property.

    static void Main(string[] args)
    {
        List<string> list = new List<string>();
        list.Add("hello");
        list.Add("goodbye");
    }
    
  3. Démarrez le débogage.Start debugging. Le espion fenêtre affiche quelque chose comme le message suivant :The Watch window shows something like the following message:

    Actualiser espionRefresh Watch

  4. Pour actualiser la valeur, sélectionnez l’icône d’actualisation, ou appuyez sur la barre d’espace.To refresh the value, select the refresh icon, or press the spacebar. Le débogueur réévalue l’expression.The debugger reevaluates the expression.

Expression effetsExpression side effects

Évaluer certaines expressions peut modifier la valeur d’une variable, ou affecter l’état de votre application.Evaluating some expressions can change the value of a variable, or otherwise affect the state of your app. Par exemple, l’évaluation de l’expression suivante modifie la valeur de var1:For example, evaluating the following expression changes the value of var1:

var1 = var2

Ce code peut entraîner un effet secondaire.This code can cause a side effect. Effets secondaires peuvent compliquer le débogage en modifiant la façon dont votre application fonctionne.Side effects can make debugging more difficult by changing the way your app operates.

Une expression avec effets secondaires est évaluée une seule fois, lorsque vous la saisissez.An expression with side effects is evaluated only once, when you first enter it. Après cela, l’expression apparaît grisée dans le espion fenêtre et davantage d’évaluations sont désactivées.After that, the expression appears grayed out in the Watch window, and further evaluations are disabled. L’info-bulle ou valeur colonne explique que l’expression provoque un effet secondaire.The tooltip or Value column explains that the expression causes a side effect. Vous pouvez forcer la réévaluation en sélectionnant l’icône d’actualisation qui apparaît en regard de la valeur.You can force reevaluation by selecting the refresh icon that appears next to the value.

Un moyen d’empêcher la désignation des effets secondaires consiste à désactiver l’évaluation de fonction automatique.One way to prevent the side effects designation is to turn off automatic function evaluation. Dans outils > Options > débogage > général, désélectionnez Activer l’évaluation de la propriété et d’autres appels de fonction implicite.In Tools > Options > Debugging > General, deselect Enable property evaluation and other implicit function calls.

Pour C# uniquement, lors de l’évaluation des propriétés ou des appels de fonction implicite est désactivée, vous pouvez forcer l’évaluation en ajoutant le ac modificateur du format à une variable nom dans le espion fenêtre.For C# only, when evaluation of properties or implicit function calls is turned off, you can force evaluation by adding the ac format modifier to a variable Name in the Watch window. Consultez Spécificateurs de format en C#.See Format specifiers in C#.

Utiliser l’ID d’objet dans la fenêtre Espion (C# et Visual Basic)Use Object IDs in the Watch window (C# and Visual Basic)

Parfois, vous souhaitez observer le comportement d’un objet spécifique.Sometimes you want to observe the behavior of a specific object. Par exemple, vous souhaiterez peut-être suivre un objet référencé par une variable locale une fois que cette variable a hors de portée.For example, you might want to track an object referred to by a local variable after that variable has gone out of scope. En C# et Visual Basic, vous pouvez créer des ID d’objet pour des instances spécifiques de types de références et les utiliser dans la fenêtre Espion et dans les conditions de point d’arrêt.In C# and Visual Basic, you can create Object IDs for specific instances of reference types, and use them in the Watch window and in breakpoint conditions. L’ID d’objet est généré par les services de débogage du Common Language Runtime (CLR) et associé à l’objet.The Object ID is generated by the common language runtime (CLR) debugging services and associated with the object.

Note

ID d’objet créent des références faibles qui n’empêchent pas l’objet d’une garbage collecté.Object IDs create weak references that don't prevent the object from being garbage collected. Leur validité ne vaut que pour la session de débogage active.They are valid only for the current debugging session.

Dans le code suivant, le MakePerson() méthode crée un Person à l’aide d’une variable locale :In the following code, the MakePerson() method creates a Person using a local variable:

class Person
{
    public Person(string name)
    {
        Name = name;
    }
    public string Name { get; set; }
}

public class Program
{
    static List<Person> _people = new List<Person>();
    public static void Main(string[] args)
    {
        MakePerson();
        DoSomething();
    }

    private static void MakePerson()
    {
        var p = new Person("Bob");
        _people.Add(p);
    }

    private static void DoSomething()
    {
        // more processing
         Console.WriteLine("done");
    }
}

Pour connaître le nom de la Person dans le DoSomething() (méthode), vous pouvez ajouter une référence à la Person ID d’objet dans le espion fenêtre.To find out the name of the Person in the DoSomething() method, you can add a reference to the Person Object ID in the Watch window.

  1. Définissez un point d’arrêt dans le code après le Person objet a été créé.Set a breakpoint in the code after the Person object has been created.

  2. Démarrez le débogage.Start debugging.

  3. Lors de l’exécution s’arrête au point d’arrêt, ouvrez le variables locales fenêtre en choisissant déboguer > Windows > devariableslocales.When execution pauses at the breakpoint, open the Locals window by choosing Debug > Windows > Locals.

  4. Dans le variables locales fenêtre, avec le bouton droit le Person variable et sélectionnez Make Object ID.In the Locals window, right-click the Person variable and select Make Object ID.

    Vous devez voir un signe dollar ($) et un nombre dans le variables locales fenêtre, qui est l’ID d’objet.You should see a dollar sign ($) plus a number in the Locals window, which is the Object ID.

  5. Ajouter l’ID d’objet pour le espion fenêtre en double-cliquant sur l’ID d’objet et en sélectionnant ajouter un espion.Add the object ID to the Watch window by right-clicking the Object ID and selecting Add Watch.

  6. Définir un autre point d’arrêt dans le DoSomething() (méthode).Set another breakpoint in the DoSomething() method.

  7. Poursuivez le débogage.Continue debugging. Lorsque l’exécution s’arrête dans le DoSomething() (méthode), le espion fenêtre affiche le Person objet.When execution pauses in the DoSomething() method, the Watch window displays the Person object.

    Note

    Si vous souhaitez voir les propriétés de l’objet, tel que Person.Name, vous devez activer l’évaluation de la propriété en sélectionnant outils > Options > Débogage > général > activer l’évaluation de la propriété et d’autres appels de fonction implicite.If you want to see the object's properties, such as Person.Name, you must enable property evaluation by selecting Tools > Options > Debugging > General > Enable property evaluation and other implicit function calls.

Affichage dynamique et la fenêtre EspionDynamic View and the Watch window

Certains langages de script (par exemple, JavaScript ou Python) utilisent dynamique ou canard tapant et .NET version 4.0 et versions ultérieure prend en charge les objets qui sont difficiles à observer dans les fenêtres de débogage normales.Some scripting languages (for example, JavaScript or Python) use dynamic or duck typing, and .NET version 4.0 and later supports objects that are difficult to observe in the normal debugging windows.

Le espion fenêtre affiche ces objets sous la forme d’objets dynamiques, qui sont créés à partir des types qui implémentent le IDynamicMetaObjectProvider interface.The Watch window displays these objects as dynamic objects, which are created from types that implement the IDynamicMetaObjectProvider interface. Nœuds de l’objet dynamique affichent les membres dynamiques des objets dynamiques, mais ne pas autoriser la modification des valeurs de membre.Dynamic object nodes show the dynamic members of the dynamic objects, but don't allow editing of the member values.

Pour actualiser affichage dynamique valeurs, sélectionnez le icône d’actualisation en regard du nœud d’objet dynamique.To refresh Dynamic View values, select the refresh icon next to the dynamic object node.

Pour afficher uniquement les affichage dynamique pour un objet, ajoutez un dynamique spécificateur de format après le nom de l’objet dynamique dans le espion fenêtre :To display only the Dynamic View for an object, add a dynamic format specifier after the dynamic object name in the Watch window:

  • Pour C# : ObjectName, dynamicFor C#: ObjectName, dynamic
  • Pour Visual Basic : $dynamic, ObjectNameFor Visual Basic: $dynamic, ObjectName

Note

  • Le C# débogueur ne réévalue automatiquement les valeurs dans le affichage dynamique quand vous passez à la ligne de code suivante.The C# debugger doesn't automatically reevaluate the values in the Dynamic View when you step to the next line of code.
  • Le débogueur de Visual Basic actualise automatiquement les expressions ajoutées via la affichage dynamique.The Visual Basic debugger automatically refreshes expressions added through the Dynamic View.
  • L’évaluation des membres d’un affichage dynamique peut avoir des effets secondaires.Evaluating the members of a Dynamic View can have side effects.

Pour insérer un nouvel espion variable qui convertit un objet vers un objet dynamique :To insert a new watch variable that casts an object to a dynamic object:

  1. Avec le bouton droit n’importe quel enfant d’un affichage dynamique.Right-click any child of a Dynamic View.
  2. Choisissez ajouter un espion.Choose Add Watch. Le object.name devient ((dynamic) object).name et s’affiche dans une nouvelle espion fenêtre.The object.name becomes ((dynamic) object).name and appears in a new Watch window.

Le débogueur ajoute également un affichage dynamique nœud enfant de l’objet à la automatique fenêtre.The debugger also adds a Dynamic View child node of the object to the Autos window. Pour ouvrir le automatique fenêtre, pendant le débogage, sélectionnez déboguer > Windows > automatique.To open the Autos window, during debugging, select Debug > Windows > Autos.

Affichage dynamique améliore également le débogage pour les objets COM.Dynamic View also enhances debugging for COM objects. Lorsque le débogueur atteint un objet COM encapsulé dans System.__ComObject, il ajoute un affichage dynamique nœud pour l’objet.When the debugger gets to a COM object wrapped in System.__ComObject, it adds a Dynamic View node for the object.

Observer une seule variable ou une expression avec Espion expressObserve a single variable or expression with QuickWatch

Vous pouvez utiliser Espion express pour observer une variable.You can use QuickWatch to observe a single variable.

Par exemple, pour le code suivant :For example, for the following code:

static void Main(string[] args)
{
    int a, b;
    a = 1;
    b = 2;
    for (int i = 0; i < 10; i++)
    {
        a = a + b;
    }
}

Pour observer le a variable,To observe the a variable,

  1. Définissez un point d’arrêt sur la ligne a = a + b; .Set a breakpoint on the a = a + b; line.

  2. Démarrez le débogage.Start debugging. L’exécution s’arrête au point d’arrêt.Execution pauses at the breakpoint.

  3. Sélectionnez la variable a dans le code.Select the variable a in the code.

  4. Sélectionnez déboguer > Espion express, appuyez sur MAJ+F9, ou avec le bouton droit et sélectionnez Espion express.Select Debug > QuickWatch, press Shift+F9, or right-click and select QuickWatch.

    Le Espion express boîte de dialogue apparaît.The QuickWatch dialog appears. Le a variable se trouve dans le Expression zone avec un valeur de 1.The a variable is in the Expression box with a Value of 1.

    Variable d’espion ExpressQuickWatch variable

  5. Pour évaluer une expression à l’aide de la variable, tapez une expression comme a + b dans le Expression zone, puis sélectionnez réévaluer.To evaluate an expression using the variable, type an expression such as a + b in the Expression box, and select Reevaluate.

    Expression Espion expressQuickWatch expression

  6. Pour ajouter la variable ou l’expression à partir de Espion express à la espion fenêtre, sélectionnez ajouter un espion.To add the variable or expression from QuickWatch to the Watch window, select Add Watch.

  7. Sélectionnez fermer pour fermer la Espion express fenêtre.Select Close to close the QuickWatch window. (Espion express est une boîte de dialogue modale, vous ne pouvez pas poursuivre le débogage tant qu’il est ouvert.)(QuickWatch is a modal dialog, so you can't continue debugging as long as it is open.)

  8. Poursuivez le débogage.Continue debugging. Vous pouvez observer la variable dans le espion fenêtre.You can observe the variable in the Watch window.

Voir aussiSee also