Surveiller les variables avec les fenêtres Espion et Espion express

Pendant le débogage, vous pouvez utiliser les fenêtres Espion et Espion express pour surveiller les variables et les expressions. Les fenêtres sont disponibles uniquement pendant une session de débogage.

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

Notes

Si c’est la première fois que vous essayez de déboguer du code, vous pouvez consulter Débogage pour grands débutants et Techniques et outils de débogage avant de poursuivre cet article.

Observer les variables avec une fenêtre Espion

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

Par exemple, pour définir un espion sur les valeurs de a, bet 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 ligne c = a + b; en cliquant dans la marge de gauche, en sélectionnant Déboguer>Activer/désactiver le point d’arrêt ou en appuyant sur F9.

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

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

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

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

   

5. Poursuivez le débogage en sélectionnant Déboguer>Effectuer un pas à pas détaillé ou en appuyant sur F11 si nécessaire pour avancer. Les valeurs des variables dans la fenêtre Espion changent à mesure que vous itérer au sein de la boucle for.

Notes

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 Espion.

• Vous pouvez ajouter des noms de registre et des noms de variables à l’aide de $<nom registre> ou @<nom registre> dans le nom de la fenêtre Espion. Pour plus d’informations, consultez Pseudovariables.

Utiliser des expressions dans une fenêtre Espion

Vous pouvez observer toute expression valide reconnue par le débogueur dans une fenêtre Espion.

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 les mêmes que dans le langage de code. Si une expression contient une erreur de syntaxe, attendez-vous à voir la même erreur de compilateur 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 Espion. Cette icône signifie que le débogueur n’évalue pas l’expression en raison d’une dépendance potentielle entre les threads. L’évaluation du code nécessite l’exécution temporaire d’autres threads dans votre application, mais comme vous êtes en mode arrêt, tous les threads de votre application sont généralement arrêtés. Permettre à 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 certains événements tels que les points d’arrêt et les exceptions sur ces threads.

Rechercher dans la fenêtre Espion

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 des propriétés dans la fenêtre Espion

Notes

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

Vous pouvez rapidement inspecter les objets en fonction de leurs propriétés dans la fenêtre Espion 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 propriété s’affiche 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 désactiver les 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 Espion. Vous pouvez accéder aux deux options en sélectionnant les boutons de la barre d’outils située au-dessus de la fenêtre espion.

Actualiser les valeurs des espions

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 la présence d’une erreur ou d’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 essaie de réévaluer l'expression. Toutefois, il se peut que vous ne souhaitiez pas ou ne puissiez pas réévaluer l’expression, selon 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 connaître la raison pour laquelle l’expression n’a pas été évaluée. En voici plusieurs raisons :

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

• L’expression contient un appel de fonction susceptible de déclencher un effet secondaire dans l’application. Consultez 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 apparaît parce que l’évaluation automatique des propriétés et des appels de fonction implicites est désactivée, vous pouvez l’activer en sélectionnant Activer l’évaluation des propriétés et d’autres appels de fonction implicites dans Outils>Options>Débogage>Général.

Pour illustrer l’utilisation de l’icône d’actualisation :

1. Dans Outils>Options>Débogage>Général, décochez la case Activer l’évaluation des propriétés et d’autres appels de fonction implicites.

2. Entrez le code suivant et, dans la fenêtre Espion, définissez un espion sur la propriété list.Count.

   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 de l’expression

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

var1 = var2

Ce code peut provoquer un effet secondaire. Les effets secondaires peuvent rendre le débogage plus difficile en altérant le fonctionnement de votre application.

Une expression avec des effets secondaires n’est évaluée qu’une seule fois, au moment où vous l’entrez. Après cela, l’expression apparaît grisée dans la fenêtre Espion et les évaluations ultérieures sont désactivées. L’infobulle 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 Outils>Options>Débogage>Général, désélectionnez Activer l’évaluation des propriétés et d’autres appels de fonction implicites.

Pour C# uniquement, quand l’évaluation des propriétés ou des appels de fonctions implicites est désactivée, vous pouvez forcer l’évaluation en ajoutant le modificateur de format ac à une variable Nom de la fenêtre Espion. Consultez Spécificateurs de format en C#.

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

Parfois, vous souhaitez observer le comportement d’un objet spécifique. Par exemple, vous pouvez souhaiter suivre un objet référencé par une variable locale devenue 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érences 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 du Common Language Runtime (CLR) et associé à l’objet.

Notes

Les ID d’objet créent des références faibles et n’empêchent pas l’objet de subir une récupération de mémoire. Leur validité ne vaut que pour la session de débogage active.

Dans le code suivant, la méthode MakePerson() crée un Person à l’aide d’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 du Person dans la méthode DoSomething(), vous pouvez ajouter une référence à l’ID d’objet Person dans la fenêtre Espion.

1. Définissez un point d’arrêt dans le code après que l’objet Person a été créé.

2. Démarrez le débogage.

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

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

   Vous devriez voir un signe dollar ($) plus un nombre dans la fenêtre Variables locales, 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 un espion.

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

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

   Notes

   Si vous souhaitez voir les propriétés de l’objet, telles que Person.Name, vous devez activer l’évaluation des propriétés en sélectionnant Outils>Options>Débogage>Général>Activer l’évaluation des propriétés et d’autres appels de fonction implicites.

Affichage dynamique et fenêtre Espion

Certains langages de script (par exemple, JavaScript ou Python) utilisent le typage dynamique ou duck, et .NET version 4.0 et ultérieure prend 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’objets dynamiques affichent les membres dynamiques des objets dynamiques, mais n’autorisent pas la modification des valeurs des membres.

Pour actualiser les valeurs de l’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

Notes

• Le débogueur C# ne réévalue pas automatiquement les valeurs de l’Affichage dynamique quand 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’un affichage dynamique peut avoir des effets secondaires.

Pour insérer une nouvelle variable espion qui caste un objet en objet dynamique :

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

Le débogueur ajoute également un nœud enfant d’affichage dynamique de l’objet à la fenêtre Automatique. Pour ouvrir la fenêtre Automatique, pendant le débogage, sélectionnez Déboguer>Fenêtres>Automatique.

L’Affichage dynamique améliore le débogage pour les objets COM. Quand le débogueur atteint un objet COM encapsulé dans System.__ComObject, il ajoute un nœud Affichage dynamique pour l’objet.

Observer une seule variable ou expression avec Espion express

Vous pouvez utiliser Espion express pour observer une variable déterminée.

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 variable a,

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>Espion express, appuyez sur Maj+F9 ou cliquez avec le bouton droit et sélectionnez Espion express.

   La boîte de dialogue Espion express s’affiche. La variable a se trouve dans la zone Expression avec une valeur de 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 Espion express à la fenêtre Espion, sélectionnez Ajouter un espion.

7. Sélectionnez Fermer pour fermer la fenêtre Espion express. (Espion express est une boîte de dialogue modale, vous ne pouvez donc pas poursuivre le débogage tant qu’elle est ouverte.)

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

Contenu connexe

• Qu’est-ce que le débogage ?
• Techniques et outils de débogage
• Aperçu du débogage
• Fenêtres du débogueur