Inspecter les variables et les valeurs de retour dans le débogueur Visual Studio

Lorsque vous essayez de déboguer un problème, vous tentez souvent de déterminer si les variables stockent les valeurs que vous attendez d’avoir dans un état d’application particulier. Certaines des fonctionnalités les plus utiles du débogueur sont celles qui vous permettent d’inspecter des variables.

Cet article explique comment inspecter les variables et afficher les valeurs de retour à l’aide du débogueur dans Visual Studio. Le débogueur offre plusieurs façons pratiques d’effectuer ces tâches, notamment les suivantes :

• Dans l'éditeur de code, vous pouvez afficher des info-bulles et des valeurs de retour en ligne.
• Dans les fenêtres du débogueur (fenêtres Autos, Locaux et Surveillance), vous pouvez afficher les valeurs des variables
• Dans les visualiseurs, vous pouvez afficher des chaînes volumineuses ou des objets .NET complexes

Ces fonctionnalités sont disponibles uniquement pendant le débogage. Pour savoir comment démarrer une session de débogage, consultez Démarrer le débogage et entrer en mode arrêt.

Remarque

Si c’est la première fois que vous avez essayé de déboguer du code, vous pouvez lire le débogage pour les débutants absolus et les techniques et outils de débogage avant de passer à cet article.

Afficher les variables dans l’éditeur de code

Souvent, lors du débogage, vous souhaitez un moyen rapide de vérifier les valeurs des propriétés des objets dans l'éditeur de code, et les conseils de données sont un bon moyen de le faire.

Lors de la pause dans le débogueur, pointez sur un objet avec la souris et vous voyez sa valeur, ou sa valeur de propriété par défaut.

Si la variable a des propriétés, vous pouvez développer l’objet pour afficher toutes ses propriétés.

Pour plus d’informations sur l’utilisation des conseils de données, consultez Afficher les valeurs de données dans les conseils de données.

Afficher les valeurs de retour inline des appels de méthode dans l’éditeur de code

Dans le code .NET et C++, vous pouvez examiner les valeurs de retour lorsque vous effectuez un pas à pas ou hors d’un appel de méthode, ce qui peut être utile lorsque la valeur de retour n’est pas stockée dans une variable locale. Une méthode peut être utilisée comme paramètre ou comme valeur de retour d’une autre méthode.

À compter de Visual Studio 2022 version 17.12, vous pouvez afficher les valeurs de retour des appels de méthode inline et pas seulement dans la fenêtre Autos.

Avec Copilot activé, vous pouvez également obtenir une assistance ciblée concernant la valeur de retour en ligne en utilisant le bouton Demander à Copilot qui apparaît dans l'infobulle pour la valeur de retour.

Surveiller les variables

Vous pouvez utiliser une fenêtre Espion pour spécifier une variable (ou une expression) à surveiller.

Lors du débogage, cliquez avec le bouton droit sur un objet dans l’éditeur de code et choisissez Ajouter une montre. Une fenêtre d'observation s'ouvre.

Dans cet exemple, vous avez défini une surveillance sur l'objet et vous pouvez voir sa valeur changer lorsque vous vous déplacez dans le débogueur. Contrairement aux autres fenêtres variables, les fenêtres Espion affichent toujours les variables que vous observez (elles sont grisées lorsqu’elles sont hors de portée).

Pour plus d’informations, consultez Définir une montre à l’aide des fenêtres Espion et QuickWatch.

Obtenir de l’aide sur l’IA

Si vous avez Copilot, vous pouvez obtenir de l’aide sur l’IA pendant que vous examinez des variables dans l’éditeur de code ou dans les fenêtres Autos ou Locals. Pendant que vous déboguez, cliquez avec le bouton droit sur une variable et utilisez le bouton Demander à Copilot. 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.

Vérifier les variables dans les fenêtres du débogueur (Autos et Locals)

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 autour de l'instruction en cours où le débogueur est suspendu. 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.

• Pour ouvrir la fenêtre Autos, lors du débogage, sélectionnez Déboguer>Windows>Autos, ou appuyez sur Ctrl+Alt+V>A.

  La fenêtre Autos est disponible pour le code C#, Visual Basic, C++ et Python, mais pas pour JavaScript ou F#.

• Pour ouvrir la fenêtre Locals, lors du débogage, sélectionnez Débogage>Fenêtre>Locals, ou appuyez sur Alt+4.

Les tableaux et objets extensibles s’affichent dans les fenêtres Autos et Locals . Sélectionnez la flèche à gauche d’un nom de variable pour développer la vue pour afficher les champs et les propriétés. Voici un exemple d’objet System.IO.FileStream dans la fenêtre Locals :

Une valeur rouge dans la fenêtre Locals ou Autos signifie que la valeur a changé depuis la dernière évaluation. La modification peut provenir d’une session de débogage précédente, ou parce que vous avez modifié la valeur dans la fenêtre.

Le format numérique par défaut dans les fenêtres du débogueur est décimal. Pour le remplacer par hexadécimal, cliquez avec le bouton droit dans la fenêtre Locals ou Autos , puis sélectionnez Affichage hexadécimal. Cette modification affecte toutes les fenêtres du débogueur.

Modifier les valeurs des variables dans la fenêtre Autos ou Locals

Pour modifier les valeurs de la plupart des variables dans les fenêtres Autos ou Locals , double-cliquez sur la valeur et entrez la nouvelle valeur.

Vous pouvez entrer une expression pour une valeur, par exemple a + b. Le débogueur accepte la plupart des expressions de langage valides.

Dans le code C++ natif, vous devrez peut-être qualifier le contexte d’un nom de variable. Pour plus d’informations, consultez l’opérateur context (C++).

Avertissement

Veillez à comprendre les conséquences avant de modifier les valeurs et les expressions. Voici quelques problèmes possibles :

• L’évaluation de certaines expressions peut modifier la valeur d’une variable ou affecter l’état de votre programme. Par exemple, l’évaluation de var1 = ++var2 modifie la valeur des deux var1 et var2. Ces expressions sont dites avoir des effets secondaires. Les effets secondaires peuvent provoquer des résultats inattendus si vous ne les connaissez pas.

• La modification des valeurs à virgule flottante peut entraîner des inexactitudes mineures en raison d’une conversion décimale en binaire des composants fractionnaires. Même une modification apparemment inoffensive peut entraîner des modifications apportées à certains des bits de la variable à virgule flottante.

Rechercher dans la fenêtre Autos ou Locals

Vous pouvez rechercher des mots clés dans les colonnes Nom, Valeur et Type de la fenêtre Autos ou Locals à 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 Autos ou Locals pour sélectionner le nombre de niveaux de profondeur que vous souhaitez rechercher dans des objets imbriqués .

Épinglez les propriétés dans la fenêtre Autos ou Locals

Remarque

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

Vous pouvez rapidement inspecter les objets en fonction de leurs propriétés dans les fenêtres Autos et Locals 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é sont affichés 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 les noms de propriété et filtrer les propriétés non épinglées lors de l'affichage de la liste des propriétés de l'objet dans les fenêtres Autos ou Locals. Vous pouvez accéder à chaque option en sélectionnant les boutons de la barre d’outils au-dessus des fenêtres Autos ou Locals.

Modifier le contexte de la fenêtre Autos ou Locals

Vous pouvez utiliser la barre d’outils Emplacement de débogage pour sélectionner une fonction, un thread ou un processus souhaité, qui modifie le contexte des fenêtres Autos et Locals .

Pour activer la barre d’outils Emplacement de débogage, cliquez dans une partie vide de la zone de barre d’outils et sélectionnez Emplacement de débogage dans la liste déroulante, ou sélectionnez Afficher>Barres d’outils>Emplacement de débogage.

Définissez un point d’arrêt et démarrez le débogage. Lorsque le point d’arrêt est atteint, l’exécution s’interrompt et vous pouvez voir l’emplacement dans la barre d’outils Emplacement du débogage .

Différences de langage dans la fenêtre Autos (C#, C++, Visual Basic, Python)

Différents langages de code affichent différentes variables dans la fenêtre Autos .

• Dans C# et Visual Basic, la fenêtre Autos affiche toute variable utilisée sur la ligne actuelle ou précédente. Par exemple, dans le code C# ou Visual Basic, déclarez les quatre variables suivantes :

       public static void Main()
       {
          int a, b, c, d;
          a = 1;
          b = 2;
          c = 3;
          d = 4;
       }
  

  Définissez un point d’arrêt sur la ligne c = 3;et démarrez le débogueur. Lorsque l’exécution s’interrompt, la fenêtre Autos s’affiche :

  

  La valeur de c est 0, car la ligne c = 3 n’a pas encore été exécutée.

• Dans C++, la fenêtre Autos affiche les variables utilisées dans au moins trois lignes avant la ligne actuelle où l’exécution est suspendue. Par exemple, dans le code C++, déclarez six variables :

       void main() {
           int a, b, c, d, e, f;
           a = 1;
           b = 2;
           c = 3;
           d = 4;
           e = 5;
           f = 6;
       }
  

  Définissez un point d’arrêt sur la ligne e = 5; et exécutez le débogueur. Lorsque l’exécution s’arrête, la fenêtre Autos s’affiche :

  

  La variable e n’est pas initialisée, car la ligne e = 5 n’a pas encore été exécutée.

Affichez les valeurs renvoyées dans la fenêtre Autos.

Dans l’exemple suivant, ce code C# ajoute les valeurs de retour de deux fonctions :

static void Main(string[] args)
{
    int a, b, c, d;
    a = 1;
    b = 2;
    c = 3;
    d = 4;
    int x = sumVars(a, b) + subtractVars(c, d);
}

private static int sumVars(int i, int j)
{
    return i + j;
}

private static int subtractVars(int i, int j)
{
    return j - i;
}

Pour afficher les valeurs de retour des appels de méthode sumVars() et subtractVars() dans la fenêtre Autos :

1. Définissez un point d’arrêt sur la ligne int x = sumVars(a, b) + subtractVars(c, d);.

2. Démarrez le débogage et, lorsque l’exécution s’interrompt au point d’arrêt, sélectionnez Pas à pas ou appuyez sur F10. Vous devez voir les valeurs de retour suivantes dans la fenêtre Autos :

   

Ouvrir un visualiseur pour inspecter les variables

Pendant que vous déboguez dans Visual Studio, vous pouvez afficher des chaînes volumineuses ou des objets complexes avec des visualiseurs intégrés qui facilitent l’inspection des données. Par exemple:

• Le visualiseur de chaînes affiche les chaînes de texte, XML, HTML et JSON qui sont trop longues pour une info-bulle de données ou une fenêtre de débogage. Il peut également vous aider à identifier les chaînes malformées. Pour plus d’informations, consultez Afficher les chaînes dans un visualiseur de chaînes.
• Les visualiseurs DataSet et IEnumerable affichent des objets de collection .NET dans un visualiseur tabulaire. Pour plus d’informations, consultez les visualiseurs tabulaires dans les objets Visual Studio.

Les visualiseurs apparaissent dans les fenêtres Autos, les info-bulles et d'autres fenêtres du débogueur.

Remarque

Si vous devez inspecter des éléments d’interface utilisateur XAML ou WPF dans un visualiseur, consultez Inspecter les propriétés XAML lors du débogage ou Comment utiliser le visualiseur d’arborescence WPF.

Pour ouvrir un visualiseur, vous devez faire une pause pendant le débogage. Placez le curseur sur une variable qui possède une valeur visualisable, puis sélectionnez l'icône en forme de loupe.

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