Observer les variables avec les fenêtres Watch et QuickWatch

Pendant que vous déboguez, vous pouvez utiliser les fenêtres Watch et QuickWatch pour observer les variables et les expressions. Les fenêtres sont disponibles uniquement pendant une session de débogage.

Les fenêtres Watch peuvent afficher plusieurs variables à la fois lors du débogage. La boîte de dialogue QuickWatch affiche une variable unique à la fois et doit être fermée avant que le débogage puisse continuer. Pour plus d’informations sur l’utilisation de QuickWatch, consultez Observer une variable ou une expression unique avec QuickWatch.

Note

Si vous débutez avec le débogage du code, vous pouvez lire le débogage pour les débutants absolus et les techniques et outils de débogage avant d’accéder à cet article.

Observer des variables avec une fenêtre de surveillance

Vous pouvez ouvrir plusieurs fenêtres Espion et observer plusieurs variables dans une fenêtre Espion .

Par exemple, pour surveiller les valeurs de a, b, et c dans le code suivant :

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éfinissez un point d’arrêt sur la c = a + b; ligne en cliquant dans la marge gauche, en sélectionnant Déboguer>Bascule du point d’arrêt ou en appuyant sur F9.

2. Démarrez le débogage en sélectionnant la flèche verte Start ou Debug>Start Debugging, ou appuyez sur F5. L’exécution s’interrompt au point d’arrêt.

3. Ouvrez une fenêtre Watch en sélectionnant Déboguer>Windows>Watch>1 ou en appuyant sur Ctrl+Alt+W>1.

   Vous pouvez ouvrir d’autres fenêtres Espion en sélectionnant windows 2, 3 ou 4.

4. Dans la fenêtre Espion , sélectionnez une ligne vide et tapez la variable a. Faites de même pour b et c.

   

5. Poursuivez le débogage en sélectionnant Déboguer>Entrer dans ou en appuyant sur F11 pour avancer si nécessaire. Les valeurs des variables dans la fenêtre Espion changent au fur et à mesure que vous effectuez une itération dans la for boucle.

Note

Pour C++ uniquement,

• Vous devrez peut-être qualifier le contexte d’un nom de variable ou une expression qui utilise un nom de variable. Le contexte est la fonction, le fichier source ou le module où se trouve une variable. Si vous devez qualifier le contexte, utilisez la syntaxe de l’opérateur de contexte (C++) dans le Nom de la fenêtre Fenêtre Espionnage.

• Vous pouvez ajouter des noms de registres et des noms de variables à l'aide de $<register name> ou @<register name> dans le champ Nom de la fenêtre Watch. Pour plus d’informations, consultez Pseudovariables.

Utiliser des expressions dans une fenêtre de surveillance

Vous pouvez observer n’importe quelle expression valide reconnue par le débogueur dans une fenêtre Surveillance.

Par exemple, pour le code de la section précédente, vous pouvez obtenir la moyenne des trois valeurs en entrant (a + b + c) / 3 dans la fenêtre Espion :

Les règles d’évaluation des expressions dans la fenêtre Espion sont généralement identiques aux règles d’évaluation des expressions dans le langage de code. Si une expression a une erreur de syntaxe, attendez-vous à la même erreur du compilateur que dans l’éditeur de code. Par exemple, une faute de frappe dans l’expression précédente génère cette erreur dans la fenêtre Espion :

Un cercle avec deux lignes ondulées peut apparaître dans la fenêtre Montre. Cette icône signifie que le débogueur n’évalue pas l’expression en raison d’une dépendance multithread potentielle. L’évaluation du code nécessite que d’autres threads de votre application s’exécutent temporairement, mais étant donné que vous êtes en mode arrêt, tous les threads de votre application sont généralement arrêtés. L’autorisation d’autres threads de s’exécuter temporairement peut avoir des effets inattendus sur l’état de votre application, et le débogueur peut ignorer des événements tels que des points d’arrêt et des exceptions sur ces threads.

Rechercher dans la fenêtre de surveillance

Vous pouvez rechercher des mots clés dans les colonnes Nom, Valeur et Type de la fenêtre Espion à l’aide de la barre de recherche au-dessus de chaque fenêtre. Appuyez sur Entrée ou sélectionnez l’une des flèches pour exécuter une recherche. Pour annuler une recherche en cours, sélectionnez l’icône « x » dans la barre de recherche.

Utilisez les flèches gauche et droite (Maj+F3 et F3, respectivement) pour naviguer entre les correspondances trouvées.

Pour rendre votre recherche plus ou moins approfondie, utilisez la liste déroulante Recherche plus approfondie en haut de la fenêtre Espion pour sélectionner le nombre de niveaux de profondeur que vous souhaitez rechercher dans des objets imbriqués.

Épingler les propriétés dans la fenêtre de surveillance

Note

Cette fonctionnalité est prise en charge dans .NET Core 3.0 ou version ultérieure.

Vous pouvez rapidement inspecter les objets par leurs propriétés dans la fenêtre de surveillance avec l'outil Propriétés épinglées. Pour utiliser cet outil, passez le curseur sur une propriété et sélectionnez l’icône d’épingle qui s’affiche ou faites un clic droit, puis sélectionnez l’option Épingler le membre comme favori dans le menu contextuel résultant. Cette action fait apparaître cette propriété en haut de la liste des propriétés de l’objet, et le nom et la valeur de la propriété s’affichent dans la colonne Valeur . Pour désépingler une propriété, sélectionnez à nouveau l’icône d’épingle ou sélectionnez l’option Désépingler le membre en tant que favori dans le menu contextuel.

Vous pouvez également basculer entre l'affichage des noms de propriétés et filtrer les propriétés non épinglées lors de l’affichage de la liste des propriétés de l’objet dans la fenêtre Observateur. Vous pouvez accéder aux deux options en sélectionnant les boutons de la barre d’outils au-dessus de la fenêtre de surveillance.

Actualiser les valeurs de surveillance

Une icône d’actualisation (flèche circulaire) peut apparaître dans la fenêtre Espion lorsqu’une expression est évaluée. L’icône d’actualisation indique une erreur ou une valeur obsolète.

Pour actualiser la valeur, sélectionnez l’icône d’actualisation ou appuyez sur la barre d’espace. Le débogueur tente de réévaluer l’expression. Toutefois, vous pouvez ne pas vouloir ou être en mesure de réévaluer l’expression, en fonction de la raison pour laquelle la valeur n’a pas été évaluée.

Pointez sur l’icône d’actualisation ou consultez la colonne Valeur pour la raison pour laquelle l’expression n’a pas été évaluée. Les raisons sont les suivantes :

• Une erreur s’est produite lors de l’évaluation de l’expression, comme dans l’exemple précédent. Un délai d’expiration peut se produire ou une variable peut être hors portée.

• L’expression a un appel de fonction qui peut déclencher un effet secondaire dans l’application. Consultez les effets secondaires de l’expression.

• L’évaluation automatique des propriétés et des appels de fonction implicites est désactivée.

Si l’icône d’actualisation s’affiche, car l’évaluation automatique des propriétés et des appels de fonction implicites est désactivée, vous pouvez mettre à jour le paramètre de débogage à partir du menuOptions des >.

Pour montrer comment utiliser l’icône d’actualisation :

1. Dans le volet Outils (ou Débogage) >Options, sous la section Tous les paramètres>Général, décochez la case >.

2. Entrez le code suivant et, dans la fenêtre Watch, ajoutez une surveillance à la list.Count propriété.

   static void Main(string[] args)
   {
       List<string> list = new List<string>();
       list.Add("hello");
       list.Add("goodbye");
   }
   

3. Démarrez le débogage. La fenêtre Espion affiche un message semblable au message suivant :

   

4. Pour actualiser la valeur, sélectionnez l’icône d’actualisation ou appuyez sur la barre d’espace. Le débogueur réévalue l’expression.

Effets secondaires d’expression

L’évaluation de certaines expressions peut modifier la valeur d’une variable ou affecter l’état de votre application. Par exemple, l’évaluation de l’expression suivante modifie la valeur de var1:

var1 = var2

Ce code peut entraîner un effet secondaire. Les effets secondaires peuvent rendre le débogage plus difficile en modifiant la façon dont votre application fonctionne.

Une expression avec effets secondaires n’est évaluée qu’une seule fois, lorsque vous l’entrez pour la première fois. Après cela, l’expression apparaît grisée dans la fenêtre Espion et d’autres évaluations sont désactivées. L’info-bulle ou la colonne Valeur explique que l’expression provoque un effet secondaire. Vous pouvez forcer la réévaluation en sélectionnant l’icône d’actualisation qui apparaît en regard de la valeur.

Une façon d’empêcher la désignation des effets secondaires consiste à désactiver l’évaluation automatique des fonctions. Dans le volet Outils (ou Débogage) >Options, sous la section Tous les paramètres>Général, décochez la case >.

Pour C# uniquement, lorsque l’évaluation des propriétés ou des appels de fonction implicites est désactivée, vous pouvez forcer l’évaluation en ajoutant le modificateur de format ac à un nom de variable dans la fenêtre Espion . Consultez les spécificateurs de format en C#.

Utiliser des ID d’objet dans la fenêtre Espion (C# et Visual Basic)

Parfois, vous souhaitez observer le comportement d’un objet spécifique. Par exemple, vous pouvez effectuer le suivi d’un objet référencé par une variable locale une fois cette variable hors de portée. En C# et Visual Basic, vous pouvez créer des ID d’objet pour des instances spécifiques de types de référence et les utiliser dans la fenêtre Espion et dans les conditions de point d’arrêt. L’ID d’objet est généré par les services de débogage CLR (Common Language Runtime) et associés à l’objet.

Note

Les ID d’objet créent des références faibles qui n’empêchent pas la collecte de déchets de l’objet. Ils sont valides uniquement pour la session de débogage actuelle.

Dans le code suivant, la méthode MakePerson() crée un Person en utilisant une variable locale.

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 Person dans la méthode DoSomething(), vous pouvez ajouter une référence à l’ID d’objet Person dans la fenêtre Affichage.

1. Définissez un point d’arrêt dans le code une fois l’objet Person créé.

2. Démarrez le débogage.

3. Lorsque l’exécution s’interrompt au niveau du point d’arrêt, ouvrez la fenêtre Locals en choisissant Déboguer>Windows>Locals.

4. Dans la fenêtre Locals , cliquez avec le bouton droit sur la Person variable, puis sélectionnez Créer un ID d’objet.

   Vous devez voir un signe dollar ($) plus un nombre dans la fenêtre Locals , qui est l’ID d’objet.

5. Ajoutez l’ID d’objet à la fenêtre Espion en cliquant avec le bouton droit sur l’ID d’objet et en sélectionnant Ajouter une montre.

6. Définissez un autre point d’arrêt dans la DoSomething() méthode.

7. Poursuivez le débogage. Lorsque l’exécution s’interrompt dans la DoSomething() méthode, la fenêtre Espion affiche l’objet Person .

   Si vous souhaitez voir les propriétés de l’objet, telles que Person.Name, vous devez activer l’évaluation des propriétés.

   Dans le volet Outils (ou Débogage), sous >Options, dans la section Tous les paramètres>Général, cochez la case >.

Vue dynamique et fenêtre de surveillance

Certains langages de script (par exemple, JavaScript ou Python) utilisent la saisie dynamique ou canard , et .NET version 4.0 et versions ultérieures prennent en charge les objets difficiles à observer dans les fenêtres de débogage normales.

La fenêtre Espion affiche ces objets en tant qu’objets dynamiques, qui sont créés à partir de types qui implémentent l’interface IDynamicMetaObjectProvider . Les nœuds d’objet dynamique affichent les membres dynamiques des objets dynamiques, mais n’autorisent pas la modification des valeurs de membre.

Pour actualiser les valeurs d’affichage dynamique , sélectionnez l’icône d’actualisation en regard du nœud d’objet dynamique.

Pour afficher uniquement l’affichage dynamique d’un objet, ajoutez un spécificateur de format dynamique après le nom de l’objet dynamique dans la fenêtre Espion :

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

Note

• Le débogueur C# ne réévalue pas automatiquement les valeurs dans la vue dynamique lorsque vous passez à la ligne de code suivante.
• Le débogueur Visual Basic actualise automatiquement les expressions ajoutées via l’affichage dynamique.
• L’évaluation des membres d’une vue dynamique peut avoir des effets secondaires.

Pour insérer une nouvelle variable de surveillance qui transforme un objet en objet dynamique :

1. Cliquez avec le bouton droit sur n’importe quel enfant d’un Dynamic View.
2. Choisissez Ajouter une montre. Le object.name devient ((dynamic) object).name et apparaît dans une nouvelle fenêtre Espion .

Le débogueur ajoute également à la fenêtre Autos un nœud enfant Vue dynamique de l'objet. Pour ouvrir la fenêtre Autos, pendant le débogage, sélectionnez Déboguer>Windows>Autos.

La vue dynamique améliore également le débogage pour les objets COM. Lorsque le débogueur accède à un objet COM encapsulé dans System.__ComObject, il ajoute un nœud d’affichage dynamique pour l’objet.

Observer une variable ou une expression unique avec QuickWatch

Vous pouvez utiliser QuickWatch pour observer une variable unique.

Par exemple, pour le code suivant :

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

Pour observer la a variable,

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

2. Démarrez le débogage. L’exécution s’interrompt au point d’arrêt.

3. Sélectionnez la variable a dans le code.

4. Sélectionnez Déboguer>QuickWatch, appuyez sur Maj+F9 ou cliquez avec le bouton droit, puis sélectionnez QuickWatch.

   La boîte de dialogue Aperçu rapide s’affiche. La a variable se trouve dans la zone Expression avec une valeurde 1.

   

5. Pour évaluer une expression à l’aide de la variable, tapez une expression telle que a + b dans la zone Expression , puis sélectionnez Réévaluer.

   

6. Pour ajouter la variable ou l’expression de QuickWatch à la fenêtre Observateur, sélectionnez Ajouter à l’Observateur.

7. Sélectionnez Fermer pour fermer la fenêtre QuickWatch . (QuickWatch est une boîte de dialogue modale, vous ne pouvez donc pas continuer le débogage tant qu’il est ouvert.)

8. Poursuivez le débogage. Vous pouvez observer la variable dans la fenêtre Espion .

Obtenir de l’aide sur l’IA

Si vous avez Copilot, vous pouvez obtenir de l'assistance de l'IA pendant que vous examinez les variables dans les fenêtres de surveillance. Cliquez avec le bouton droit sur une variable et utilisez le Screenshot of Ask Copilot button. Dans ce scénario, Copilot connaît déjà le contexte de votre question. Vous n’avez donc pas besoin de fournir le contexte vous-même dans la conversation. Pour plus d’informations, consultez Déboguer avec Copilot.

Contenu connexe

• Qu’est-ce que le débogage ?
• Techniques et outils de débogage
• Tout d’abord, examinez le débogage
• Les fenêtres du débogueur