Exercice - Surveiller les variables et le flux d’exécution

13 minutes

La vue RUN AND DEBUG offre aux développeurs un moyen simple de surveiller les variables et les expressions, d’observer le flux d’exécution et de gérer les points d’arrêt pendant le processus de débogage.

Examiner les sections de la vue Exécuter et Déboguer

Chaque section de la vue RUN AND DEBUG fournit des fonctionnalités uniques. L’utilisation d’une combinaison de ces sections pendant le processus de débogage est souvent utile.

Section VARIABLES

L’état des variables de surveillance est un aspect important du débogage du code. Les changements inattendus dans l’état des variables aident souvent à identifier les erreurs logiques dans votre code.

La section VARIABLES organise vos variables par étendue. L’étendue Locals affiche les variables dans l’étendue actuelle (la méthode actuelle).

Remarque

La section instructions de niveau supérieur d’une application console est considérée comme sa propre méthode. Méthode nommée Main.

Vous pouvez déployer (développer) les étendues affichées en sélectionnant la flèche à gauche du nom de l’étendue. Vous pouvez également déployer des variables et des objets. La capture d’écran suivante montre le tableau numbers déplié sous l’étendue Locals.

Capture d’écran montrant une variable dépliée dans la section Variables de la vue Exécuter et déboguer.

Il est également possible de modifier la valeur d’une variable au moment de l’exécution à l’aide de la section VARIABLES. Vous pouvez double-cliquer sur le nom de la variable, puis entrer une nouvelle valeur.

Section ESPION

Que se passe-t-il si vous souhaitez suivre un état variable à travers le temps ou différentes méthodes ? Il peut être fastidieux de rechercher la variable à chaque fois. C’est là que la section WATCH est pratique.

Vous pouvez sélectionner le bouton Ajouter une expression (apparaît sous la forme d’un signe plus : +) pour entrer un nom de variable ou une expression à regarder. En guise d’alternative, vous pouvez cliquer avec le bouton droit sur une variable dans la section VARIABLES et sélectionner Add to watch.

Toutes les expressions de la section WATCH seront mises à jour automatiquement à mesure que votre code s’exécute.

SECTION PILE DES APPELS

Chaque fois que votre code entre une méthode à partir d’une autre méthode, une couche d’appels est ajoutée à la pile des appels de l’application. Lorsque votre application devient complexe et que vous avez une longue liste de méthodes appelées par d'autres méthodes, la pile d'appels représente la trace des appels de méthode.

La section CALL STACK est utile lorsque vous essayez de trouver l’emplacement source d’une exception ou d’une expression WATCH. Si votre application lève une exception inattendue, un message s’affiche souvent dans la console qui ressemble à ce qui suit :

Exception has occurred: CLR/System.DivideByZeroException
An unhandled exception of type 'System.DivideByZeroException' occurred in Debug1.dll: 'Attempted to divide by zero.'
    at Program.<<Main>$>g__WriteMessage|0_1() in C:\Users\howdc\Desktop\Debug1\Program.cs:line 27
    at Program.<<Main>$>g__Process1|0_0() in C:\Users\howdc\Desktop\Debug1\Program.cs:line 16
    at Program.<Main>$(String[] args) in C:\Users\howdc\Desktop\Debug1\Program.cs:line 10

Le groupe indenté de lignes at Program ... situées sous le message d’erreur est appelé une trace de pile. La trace de pile donne le nom et l’origine de chaque méthode qui a été appelée avant de se terminer par l’exception. Les informations peuvent être un peu difficiles à déchiffrer, car elles peuvent également inclure des informations à partir du runtime .NET. Dans cet exemple, la trace de pile est assez propre et vous pouvez voir que cette exception s’est produite dans une méthode nommée WriteMessage. La pile provient d’une méthode nommée Main, qui est la section d’instructions de niveau supérieur de l’application console.

La section PILE DES APPELS peut vous aider à éviter la difficulté de déchiffrer une trace de pile qui est encombrée d’informations d’exécution .NET. Il filtre les informations indésirables pour vous montrer uniquement les méthodes pertinentes de votre propre code par défaut. Vous pouvez décompresser manuellement la pile des appels pour savoir où provient l’exception.

SECTION POINTS D’ARRÊT

La section BREAKPOINTS affiche les paramètres de point d’arrêt actuels et peut être utilisée pour activer ou désactiver des points d’arrêt spécifiques pendant une session de débogage.

Configurer votre application et lancer la configuration

Lorsque vous travaillez sur une application console qui lit l’entrée utilisateur, vous devrez probablement mettre à jour le fichier de configuration de lancement.

Mettez à jour le code dans votre fichier Program.cs comme suit :

string? readResult;
int startIndex = 0;
bool goodEntry = false;

int[] numbers = { 1, 2, 3, 4, 5 };

// Display the array to the console.
Console.Clear();
Console.Write("\n\rThe 'numbers' array contains: { ");
foreach (int number in numbers)
{
    Console.Write($"{number} ");
}

// To calculate a sum of array elements, 
//  prompt the user for the starting element number.
Console.WriteLine($"}}\n\r\n\rTo sum values 'n' through 5, enter a value for 'n':");
while (goodEntry == false)
{
    readResult = Console.ReadLine();
    goodEntry = int.TryParse(readResult, out startIndex);

    if (startIndex > 5)
    {
        goodEntry = false;
        Console.WriteLine("\n\rEnter an integer value between 1 and 5");
    }
}

// Display the sum and then pause.
Console.WriteLine($"\n\rThe sum of numbers {startIndex} through {numbers.Length} is: {SumValues(numbers, startIndex)}");

Console.WriteLine("press Enter to exit");
readResult = Console.ReadLine();

// This method returns the sum of elements n through 5
static int SumValues(int[] numbers, int n)
{
    int sum = 0;
    for (int i = n; i < numbers.Length; i++)
    {
        sum += numbers[i];
    }
    return sum;
}

Prenez le temps de passer le code en revue.

Notez les points suivants :
- Le code spécifie un tableau entier contenant cinq nombres.
- Le code affiche le résultat dans la console.
- Le code invite l’utilisateur à entrer un numéro n d’élément de départ qu’il utilise pour additionner des éléments n de tableau via 5.
- Le code calcule la somme dans une méthode, affiche les résultats dans la console, puis s’interrompt.
Remarque

Le panneau CONSOLE DEBUG ne prend pas en charge l’entrée utilisateur à partir de la console.
Dans le menu Fichier Visual Studio Code, sélectionnez Enregistrer.
Dans le menu Exécuter , sélectionnez Supprimer tous les points d’arrêt.

Cela supprime tous les points d’arrêt restants de l’exercice précédent.
Dans la vue RUN AND DEBUG, sélectionnez Démarrer le débogage.
Notez qu’une erreur se produit lorsque la ligne de Console.Clear(); code est exécutée.
Dans la barre d’outils Déboguer, sélectionnez Arrêter.
Basculez vers l’affichage EXPLORATEUR, puis ouvrez le fichier launch.json dans l’éditeur.
Mettez à jour la valeur de l’attribut console comme suit :
```
"console":"integratedTerminal",
```
Dans le menu Fichier Visual Studio Code, sélectionnez Enregistrer, puis fermez le fichier launch.json.

Passer en revue la sortie de l’application et identifier les problèmes

L’examen de la sortie de votre application peut révéler des problèmes logiques que vous avez négligés lors de l’écriture de votre code.

Revenez à la vue RUN AND DEBUG.
Dans la vue RUN AND DEBUG, sélectionnez Démarrer le débogage.

Les messages affichés dans le panneau CONSOLE DEBUG indiquent que le débogueur s'attache à l'application Debug101.dll.
Notez qu’aucun message d’erreur n’est affiché.

La modification de la valeur de l’attribut consoleinternalConsole en integratedTerminal dans le fichier de configuration de lancement a résolu l’erreur de console. Mais maintenant, vous devez localiser la console qui contient votre sortie.
Dans la zone Panneaux sous l’Éditeur, basculez du panneau CONSOLE DEBUG vers le panneau TERMINAL.
Notez que l’exécution du code a été suspendue au message invitant l’utilisateur à entrer une valeur pour n.

La sortie du panneau TERMINAL doit ressembler à ce qui suit :
```
The 'numbers' array contains: { 1 2 3 4 5 }

To sum values 'n' through 5, enter a value for 'n':
```
Dans l’invite de commandes Terminal, entrez 3

Passez en revue la sortie de l’application.

La sortie du panneau TERMINAL doit ressembler à ce qui suit :


The 'numbers' array contains: { 1 2 3 4 5 }

To sum values 'n' through 5, enter a value for 'n':
3

The sum of numbers 3 through 5 is: 9
press Enter to exit

Prenez une minute pour considérer la valeur signalée de sum et les valeurs des éléments du tableau 3 à 5 affichées en haut de la console.

Le message indique : The sum of numbers 3 through 5 is: 9. Toutefois, les éléments de tableau 3 à 5 sont 3, 4et 5. La somme signalée ne devrait-elle pas être 12 ?

Vous pouvez utiliser la section VARIABLES de la vue RUN AND DEBUG pour examiner le problème.

Surveiller l’état des variables

Dans certains cas, la supervision de l’état des variables suffit pour identifier le problème logique dans votre application.

Définissez un point d’arrêt sur la ligne de code suivante :

Console.WriteLine($"\n\rThe sum of numbers {startIndex} through {numbers.Length} is: {SumValues(numbers, startIndex)}");

Dans la vue RUN AND DEBUG, sélectionnez Démarrer le débogage.
Basculez du panneau CONSOLE DE DÉBOGAGE vers le panneau TERMINAL.
Dans l’invite de commandes Terminal, entrez 3

L’exécution du code s’interrompt au point d’arrêt.
Prenez une minute pour passer en revue la section VARIABLES de la vue RUN AND DEBUG.

Notez que startIndex a été assigné à la valeur que vous avez entrée, qui est 3.
Sélectionnez Entrer dans.
Notez que les sections VARIABLES et CALL STACK sont mises à jour.

La section CALL STACK montre que l’exécution du code a été déplacée dans la SumValues méthode.

La section VARIABLES, qui répertorie les variables locales, affiche la valeur de l’entier n. Le paramètre n de méthode est affecté à sa valeur à partir de l’argument startIndexd’appel de méthode. Dans ce cas, la modification apportée aux noms de variables permet de préciser que la valeur a été passée, et non pas un pointeur de référence.

Remarque

Dans ce cas, vous pouvez voir la plupart de votre code dans l’éditeur. Vous n’avez peut-être pas besoin de la section CALL STACK, mais lorsque vous travaillez sur des applications plus volumineuses avec des appels de méthode profondément imbriqués et interconnectés, le chemin d’exécution indiqué dans la section CALL STACK peut être extrêmement utile.
Continuez à sélectionner Plonger dans jusqu'à ce que la valeur affectée à sum ne soit plus 0.
Prenez une minute pour passer en revue les informations affichées dans la section VARIABLES.

Les éléments suivants doivent s’afficher :

Notez que la valeur affectée à sum est passée de 0 à 4.
Pour développer le numbers tableau, sélectionnez des nombres [int[]].
Rappelez-vous que les éléments de tableau sont accessibles à l’aide de numéros d’index de base zéro.

Dans ce cas, l’erreur logique est un écart entre les instructions de l’interface utilisateur et le code sous-jacent. L’interface utilisateur fait référence aux éléments de tableau 1 à 5. Toutefois, le code utilise la valeur entrée par l’utilisateur pour accéder aux éléments de tableau de base zéro. Élément de tableau qui a un index de 3 stocke une valeur de 4. Le code ne compensera pas les indices commençant à zéro.
Pour terminer la session de débogage, sélectionnez Arrêter.
Prenez une minute pour prendre en compte la façon dont vous pouvez résoudre le problème.

Ce problème peut être corrigé dans l’interface utilisateur en invitant l’utilisateur à entrer une valeur comprise entre 0 et 4. Elle peut également être corrigée dans le code en soustrayant 1 de la valeur entrée. En règle générale, votre objectif doit être clair et facile à suivre. Dans ce cas, il peut être préférable de mettre à jour le code comme suit :
```
Console.WriteLine($"\n\rThe sum of numbers {startIndex} through {numbers.Length} is: {SumValues(numbers, startIndex - 1)}");
```
L’exécution du code mis à jour génère la sortie suivante :
Mettez à jour votre code à l’aide de l’approche suggérée, puis enregistrez votre fichier Program.cs.
Effacez votre point d’arrêt, réexécutez l’application dans le débogueur et vérifiez que le résultat prévu s’affiche dans le TERMINAL.

Vous venez d’utiliser l’état de variable pour identifier et résoudre un problème logique ! Bon travail.

Surveiller les expressions espion

La section WATCH peut être utilisée pour surveiller les expressions basées sur une ou plusieurs variables.

Supposons que vous travaillez sur une application qui effectue des calculs numériques sur un jeu de données. Vous pensez que votre code produit des résultats non fiables lorsque le rapport entre deux variables numériques est supérieur à 5. Vous pouvez utiliser la section WATCH pour surveiller le ratio calculé.

Mettez à jour le fichier Program.cs avec le code suivant :

bool exit = false;
var rand = new Random();
int num1 = 5;
int num2 = 5;

do
{
    num1 = rand.Next(1, 11);
    num2 = num1 + rand.Next(1, 51);

} while (exit == false);

Enregistrez votre fichier Program.cs.
Définissez un point d’arrêt sur la ligne de code finale.
Définissez l’expression WATCH suivante :
```
num2 / num1 > 5
```
Dans la vue RUN AND DEBUG, sélectionnez Démarrer le débogage.
Notez les valeurs affichées dans les sections VARIABLES et WATCH.
Sélectionnez Continuer jusqu’à ce que l’expression WATCH soit évaluée à true.

Si l’expression WATCH a été évaluée true sur la première itération, sélectionnez Continuer quelques fois plus ou jusqu’à ce que vous voyiez true une seconde fois.
Prenez une minute pour prendre en compte la façon dont la section WATCH est utilisée.

Dans ce scénario, vous avez déterminé que votre code produit des résultats non fiables lorsque le rapport entre deux variables numériques est supérieur à 5. Vous avez construit une expression dans la section WATCH qui représente cette condition. Vous pouvez maintenant utiliser la section WATCH pour suivre cette condition.

Modifier la valeur affectée à une variable dans la section VARIABLES

Il peut arriver que vous souhaitiez créer une condition programmatique manuellement. La section VARIABLES de la vue RUN AND DEBUG vous permet de le faire en modifiant l’état d’une variable au moment de l’exécution.

Prenez une minute pour passer en revue le code que vous exécutez.

Notez que le code ne sortira jamais de la boucle do, car exit ne sera jamais true. Il ne s’agit pas d’une condition programmatique que vous avez besoin de modifier dans une application réelle, mais elle illustre la fonctionnalité.
Dans la section VARIABLES, cliquez avec le bouton exit [bool]droit, puis sélectionnez Définir la valeur.

La section VARIABLES vous permet de modifier la valeur affectée à une variable au moment de l’exécution. Cela peut être utile lorsque vous souhaitez voir comment votre code réagit à une condition particulière.
Pour définir la valeur de exit à true, tapez true, puis appuyez sur Entrée.

Dans ce cas, changer la valeur de exit en true entraînera la fermeture de l'application lorsque l'instruction while sera exécutée.
Sélectionnez Continuer.
Notez que le panneau CONSOLE DEBUG affiche un message vous informant que le programme s'est terminé.

Félicitations! Vous avez correctement utilisé les sections VARIABLES et WATCH de la vue RUN AND DEBUG.

Récapitulatif

Voici quelques points importants à retenir de cette unité :

Surveillez l’état des variables à l’aide de la section VARIABLES de la vue RUN AND DEBUG.
Effectuez le suivi d’une expression dans le temps ou de différentes méthodes à l’aide de la section WATCH de la vue RUN AND DEBUG.
Utilisez la section PILE DES APPELS de la vue EXÉCUTER ET DÉBOGUER pour rechercher l’emplacement source d’une exception ou d’une expression ESPION.
Utilisez la section VARIABLES pour modifier la valeur affectée d’une variable au moment de l’exécution.

Commentaires

Cette page a-t-elle été utile ?