Übung: Überwachen von Variablen und Ausführungsablauf

13 Minuten

Die RUN AND DEBUG-Ansicht bietet Entwicklern eine einfache Möglichkeit, Variablen und Ausdrücke zu überwachen, den Ausführungsfluss zu beobachten und Haltepunkte während des Debugvorgangs zu verwalten.

Überprüfen der Abschnitte der Ansicht "Ausführen" und "Debuggen"

Jeder Abschnitt der RUN AND DEBUG-Ansicht bietet eindeutige Funktionen. Die Verwendung einer Kombination dieser Abschnitte während des Debugvorgangs ist häufig hilfreich.

ABSCHNITT VARIABLEN

Das Überwachen des Variablenzustands ist ein wichtiger Aspekt des Codedebuggings. Unerwartete Änderungen im Variablenzustand helfen häufig bei der Identifizierung von Logikfehlern in Ihrem Code.

Der Abschnitt VARIABLEN organisiert Ihre Variablen nach Bereich. Der Locals Bereich zeigt die Variablen im aktuellen Bereich (die aktuelle Methode) an.

Hinweis

Der Abschnitt "Anweisungen der obersten Ebene" einer Konsolenanwendung wird als eigene Methode betrachtet. Eine Methode mit dem Namen Main.

Sie können die angezeigten Bereiche aufklappen, indem Sie den Pfeil links neben dem Bereichsnamen auswählen. Sie können Variablen und Objekte auch erweitern. Der folgende Screenshot zeigt das erweiterte numbers-Array unter dem Bereich Locals.

Screenshot einer sich entfaltenden Variablen im Abschnitt

Es ist auch möglich, den Wert einer Variablen zur Laufzeit mithilfe des ABSCHNITTS VARIABLEN zu ändern. Sie können auf den Variablennamen doppelklicken und dann einen neuen Wert eingeben.

WATCH-Abschnitt

Was geschieht, wenn Sie einen variablen Zustand über einen Zeitraum oder verschiedene Methoden nachverfolgen möchten? Es kann mühsam sein, jedes Mal nach der Variablen zu suchen. Hier ist der WATCH-Abschnitt praktisch.

Sie können die Schaltfläche "Ausdruck hinzufügen " auswählen (wird als Pluszeichen angezeigt: +), um einen Variablennamen oder einen zu überwachenden Ausdruck einzugeben. Alternativ können Sie im Abschnitt VARIABLEN mit der rechten Maustaste auf eine Variable klicken und dann auswählen Add to watch.

Alle Ausdrücke innerhalb des WATCH-Abschnitts werden automatisch aktualisiert, wenn Ihr Code ausgeführt wird.

Abschnitt CALL STACK

Jedes Mal, wenn Ihr Code eine Methode aus einer anderen Methode eingibt, wird dem Aufrufstapel der Anwendung eine Aufrufebene hinzugefügt. Wenn Ihre Anwendung komplex wird und Sie über eine lange Liste von Methoden verfügen, die von anderen Methoden aufgerufen werden, stellt der Aufrufstapel den Pfad von Methodenaufrufen dar.

Der Abschnitt CALL STACK ist nützlich, wenn Sie die Quelle für eine Ausnahme oder einen Ausdruck im Abschnitt WATCH ermitteln möchten. Wenn Ihre Anwendung eine unerwartete Ausnahme auslöst, wird häufig eine Meldung in der Konsole angezeigt, die etwa wie folgt aussieht:

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

Die eingerückte Gruppe von at Program ...-Zeilen unterhalb der Fehlermeldung wird als Stapelüberwachung bezeichnet. Die Stapelablaufverfolgung listet den Namen und den Ursprung jeder Methode auf, die bis zur Ausnahme aufgerufen wurde. Die Informationen können jedoch etwas schwierig zu entschlüsseln sein, da sie auch Informationen aus der .NET-Laufzeit enthalten kann. In diesem Beispiel ist die Stapelablaufverfolgung ziemlich sauber und Sie können sehen, dass die Ausnahme in einer Methode mit dem Namen WriteMessageaufgetreten ist. Der Stapel stammt aus einer Methode namens Main, die der Abschnitt mit den Anweisungen der obersten Ebene der Konsolenanwendung ist.

Der CALL STACK-Abschnitt kann Ihnen helfen, die Schwierigkeiten zu vermeiden, eine Stapelablaufverfolgung zu entschlüsseln, die mit .NET-Laufzeitinformationen überladen ist. Es filtert unerwünschte Informationen aus, um Ihnen nur die relevanten Methoden aus Ihrem eigenen Code standardmäßig anzuzeigen. Sie können die Aufrufliste manuell entladen, um herauszufinden, wo die Ausnahme ihren Ursprung hat.

Abschnitt BREAKPOINTS

Im ABSCHNITT BREAKPOINTS werden die aktuellen Haltepunkteinstellungen angezeigt und können verwendet werden, um bestimmte Haltepunkte während einer Debugsitzung zu aktivieren oder zu deaktivieren.

Konfigurieren Sie Ihre Anwendung und Startkonfiguration

Wenn Sie an einer Konsolenanwendung arbeiten, die Benutzereingaben liest, müssen Sie wahrscheinlich die Startkonfigurationsdatei aktualisieren.

Aktualisieren Sie den Code in Ihrer Program.cs Datei wie folgt:

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;
}

Überprüfen Sie kurz den Code.

Beachten Sie Folgendes:
- Der Code gibt ein ganzzahliges Array an, das fünf Zahlen enthält.
- Der Code zeigt die Ausgabe in der Konsole an.
- Der Code fordert den Benutzer auf, eine Startelementnummer n einzugeben, die verwendet wird, um die Arrayelemente von n bis 5 zu addieren.
- Der Code berechnet die Summe in einer Methode, zeigt die Ergebnisse in der Konsole an und hält dann an.
Hinweis

Der DEBUG CONSOLE-Bereich unterstützt keine Benutzereingaben über die Konsole.
Wählen Sie im Menü "Visual Studio Code-Datei " die Option "Speichern" aus.
Wählen Sie im Menü Ausführen die Option "Alle Haltepunkte entfernen" aus.

Dadurch werden alle Haltepunkte entfernt, die noch aus der vorangegangenen Übung stammen.
Wählen Sie in der Ansicht "AUSFÜHREN UND DEBUGGEN" die Option "Debuggen starten" aus.
Beachten Sie, dass beim Ausführen der Console.Clear(); Codezeile ein Fehler auftritt.
Wählen Sie auf der Symbolleiste "Debuggen" die Option "Beenden" aus.
Wechseln Sie zur EXPLORER-Ansicht, und öffnen Sie dann die launch.json Datei im Editor.
Aktualisieren Sie den Wert des console Attributs wie folgt:
```
"console":"integratedTerminal",
```
Wählen Sie im Menü "Visual Studio Code-Datei " die Option "Speichern" aus, und schließen Sie dann die launch.json Datei.

Überprüfen der Anwendungsausgabe und Identifizieren von Problemen

Wenn Sie die Ausgabe Ihrer Anwendung überprüfen, können Logikprobleme angezeigt werden, die Sie beim Schreiben des Codes übersehen haben.

Wechseln Sie zurück zur RUN AND DEBUG-Ansicht.
Wählen Sie in der Ansicht "AUSFÜHREN UND DEBUGGEN" die Option "Debuggen starten" aus.

Die im DEBUG CONSOLE-Bereich angezeigten Meldungen zeigen den Debugger an, der an die Debug101.dll Anwendung angefügt ist.
Beachten Sie, dass keine Fehlermeldungen angezeigt werden.

Durch die Änderung des console-Attributwerts von internalConsole inintegratedTerminal in der Startkonfigurationsdatei wurde der Konsolenfehler behoben. Aber jetzt müssen Sie die Konsole ausfindig machen, die Ihre Ausgabe enthält.
Wechseln Sie im Panelbereich unterhalb des Editors vom Panel DEBUG CONSOLE zum Panel TERMINAL.
Beachten Sie, dass die Codeausführung an der Meldung angehalten wurde, in der der Benutzer aufgefordert wird, einen Wert für neinzugeben.

Die Ausgabe im Panel TERMINAL sollte wie folgt aussehen:
```
The 'numbers' array contains: { 1 2 3 4 5 }

To sum values 'n' through 5, enter a value for 'n':
```
Geben Sie an der TERMINAL-Eingabeaufforderung 3 ein.

Überprüfen Sie die Ausgabe der Anwendung.

Die Ausgabe im Panel TERMINAL sollte wie folgt aussehen:


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

Nehmen Sie sich eine Minute Zeit, um den gemeldeten Wert sum und die Werte von Arrayelementen 3 bis 5 zu berücksichtigen, die oben in der Konsole angezeigt werden.

Die Meldung besagt: The sum of numbers 3 through 5 is: 9. Arrayelemente 3 bis 5 sind jedoch 3, 4 und 5. Sollte die gemeldete Summe nicht 12 sein?

Sie können den ABSCHNITT VARIABLEN der RUN AND DEBUG-Ansicht verwenden, um das Problem zu untersuchen.

Überwachen des Variablenzustands

In einigen Fällen reicht einfach die Überwachung des Variablenzustands aus, um das Logische Problem in Ihrer Anwendung zu identifizieren.

Legen Sie einen Haltepunkt in der folgenden Codezeile fest:

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

Wählen Sie in der Ansicht "AUSFÜHREN UND DEBUGGEN" die Option "Debuggen starten" aus.
Wechseln Sie vom DEBUG CONSOLE Panel zum TERMINAL-Panel.
Geben Sie an der TERMINAL-Eingabeaufforderung 3 ein.

Die Codeausführung wird am Haltepunkt angehalten.
Nehmen Sie sich eine Minute Zeit, um den Abschnitt "VARIABLEN" der ANSICHT "AUSFÜHREN UND DEBUGGEN" zu überprüfen.

Beachten Sie, dass startIndex ihnen der von Ihnen eingegebene Wert zugewiesen wurde. Dies ist 3.
Wählen Sie Einzelschritt aus.
Beachten Sie, dass die ABSCHNITTE VARIABLEN und CALL STACK aktualisiert werden.

Im ABSCHNITT CALL STACK wird gezeigt, dass die Codeausführung in die SumValues Methode verschoben wurde.

Der ABSCHNITT VARIABLEN, in dem die lokalen Variablen aufgelistet sind, zeigt den Wert der ganzen Zahl nan. Dem Methodenparameter n wird der Wert aus dem Methodenaufrufargument startIndexzugewiesen. In diesem Fall macht die Änderung der Variablennamen deutlich, dass nicht ein Referenzzeiger, sondern der Wert übergeben wurde.

Hinweis

In diesem Fall können Sie den größten Teil Ihres Codes im Editor sehen, daher benötigen Sie möglicherweise nicht den ABSCHNITT CALL STACK, aber wenn Sie an größeren Anwendungen mit tief geschachtelten und miteinander verbundenen Methodenaufrufen arbeiten, kann der im ABSCHNITT CALL STACK gezeigte Ausführungspfad äußerst nützlich sein.
Wählen Sie so lange Einzelschritt aus, bis der sum zugewiesene Wert nicht mehr 0 lautet.
Nehmen Sie sich eine Minute Zeit, um die im Abschnitt VARIABLEN angezeigten Informationen zu überprüfen.

Sie sollten Folgendes sehen:

Beachten Sie, dass der Wert, der sum zugewiesen wurde, sich von 0 zu 4 geändert hat.
Um das numbers Array zu erweitern, wählen Sie Zahlen [int[]].
Erinnern Sie sich daran, dass auf Arrayelemente mit nullbasierten Indexnummern zugegriffen wird.

In diesem Fall ist der Logikfehler eine Diskrepanz zwischen den Anweisungen auf der Benutzeroberfläche und dem zugrunde liegenden Code. Die Benutzeroberfläche bezieht sich auf Arrayelemente 1-5. Der Code verwendet jedoch den vom Benutzer eingegebenen Wert, um auf die nullbasierten Arrayelemente zuzugreifen. Das Arrayelement, das den Index von 3 hat, speichert den Wert von 4. Der Code entschädigt nicht die nullbasierten Indexnummern.
Um die Debugsitzung zu beenden, wählen Sie "Beenden" aus.
Nehmen Sie sich eine Minute Zeit, um zu überlegen, wie Sie das Problem beheben können.

Dieses Problem konnte in der Benutzeroberfläche behoben werden, indem der Benutzer aufgefordert wird, einen Wert zwischen 0 und 4 einzugeben. Sie könnte auch im Code korrigiert werden, indem 1 vom eingegebenen Wert subtrahiert wird. Im Allgemeinen sollte Ihr Ziel eine klare und benutzerfreundliche Benutzeroberfläche sein. In diesem Fall ist es möglicherweise besser, den Code wie folgt zu aktualisieren:
```
Console.WriteLine($"\n\rThe sum of numbers {startIndex} through {numbers.Length} is: {SumValues(numbers, startIndex - 1)}");
```
Durch Ausführen des aktualisierten Codes wird die folgende Ausgabe erzeugt:
Aktualisieren Sie Ihren Code mithilfe des vorgeschlagenen Ansatzes, und speichern Sie dann ihre Program.cs Datei.
Löschen Sie Ihren Haltepunkt, führen Sie die Anwendung im Debugger erneut aus, und stellen Sie sicher, dass das beabsichtigte Ergebnis im TERMINAL angezeigt wird.

Sie haben gerade den Variablenzustand verwendet, um ein Logikproblem zu identifizieren und zu beheben! Tolle Arbeit.

Überwachen von Überwachungsausdrücken

Der WATCH-Abschnitt kann verwendet werden, um Ausdrücke zu überwachen, die auf einer oder mehreren Variablen basieren.

Angenommen, Sie arbeiten an einer Anwendung, die numerische Berechnungen für einen Datensatz durchführt. Sie glauben, dass Ihr Code unzuverlässige Ergebnisse erzeugt, wenn das Verhältnis zwischen zwei numerischen Variablen größer als 5 ist. Sie können den WATCH-Abschnitt verwenden, um das berechnete Verhältnis zu überwachen.

Aktualisieren Sie die Program.cs-Datei mit dem folgenden Code:

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);

Speichern Sie Ihre Program.cs Datei.
Legen Sie einen Haltepunkt in der endgültigen Codezeile fest.
Legen Sie den folgenden WATCH-Ausdruck fest:
```
num2 / num1 > 5
```
Wählen Sie in der Ansicht "AUSFÜHREN UND DEBUGGEN" die Option "Debuggen starten" aus.
Beachten Sie die Werte, die in den Abschnitten VARIABLEN und WATCH angezeigt werden.
Wählen Sie so lange Weiter aus, bis der Überwachungswert als true ausgewertet wird.

Wenn der WATCH-Ausdruck bei der ersten Iteration auf true ausgewertet wird, wählen Sie "Weiter" noch ein paar Mal aus, oder bis Sie true ein zweites Mal sehen.
Nehmen Sie sich eine Minute Zeit, um zu überlegen, wie der WATCH-Abschnitt verwendet wird.

In diesem Szenario haben Sie festgestellt, dass Ihr Code unzuverlässige Ergebnisse erzeugt, wenn das Verhältnis zwischen zwei numerischen Variablen größer als 5 ist. Sie haben einen Ausdruck im WATCH-Abschnitt erstellt, der diese Bedingung darstellt. Dadurch können Sie den Abschnitt WATCH verwenden, um diese Bedingung nachzuverfolgen.

Ändern des Werts, der einer Variablen im Abschnitt VARIABLEN zugewiesen ist

Es kann vorkommen, dass Sie eine programmgesteuerte Bedingung manuell erstellen möchten. Mit dem ABSCHNITT VARIABLEN in der RUN AND DEBUG-Ansicht können Sie dies tun, indem Sie den Zustand einer Variablen zur Laufzeit ändern.

Nehmen Sie sich eine Minute Zeit, um den Code zu überprüfen, den Sie ausführen.

Beachten Sie, dass der Code nie aus der do Schleife austritt, da exit nie true sein wird. Dies ist keine programmgesteuerte Bedingung, die Sie in einer realen Anwendung ändern müssen, aber sie veranschaulicht die Funktion.
Klicken Sie im Abschnitt VARIABLEN mit der rechten Maustaste exit [bool], und wählen Sie dann "Wert festlegen" aus.

Im Abschnitt VARIABLEN können Sie den Wert ändern, der einer Variablen zur Laufzeit zugewiesen ist. Dies kann hilfreich sein, wenn Sie sehen möchten, wie Ihr Code auf eine bestimmte Bedingung reagiert.
Um den Wert von exit auf true festzulegen, geben Sie true ein und drücken Sie dann die EINGABETASTE.

In diesem Fall bewirkt die Änderung des Werts von exit zu true, dass die Anwendung geschlossen wird, wenn die Anweisung while ausgeführt wird.
Wählen Sie "Weiter" aus.
Beachten Sie, dass im DEBUG CONSOLE-Bereich eine Meldung angezeigt wird, die Sie darüber informiert, dass das Programm beendet wurde.

Glückwunsch! Sie haben die Abschnitte VARIABLES und WATCH der Ansicht RUN AND DEBUG erfolgreich genutzt.

Rekapitulation

Nachstehend finden Sie nochmals die wichtigsten Punkte aus dieser Lerneinheit:

Überwachen des Variablenzustands mithilfe des Abschnitts VARIABLEN der RUN AND DEBUG-Ansicht.
Verwenden Sie den Abschnitt WATCH in der Ansicht RUN AND DEBUG, um einen Ausdruck im zeitlichen Verlauf oder über verschiedene Methoden hinweg nachzuverfolgen.
Verwenden Sie den Abschnitt CALL STACK in der Ansicht RUN AND DEBUG, um den Ursprung einer Ausnahme oder eines Überwachungsausdrucks zu ermitteln.
Verwenden Sie den Abschnitt VARIABLEN, um den zugewiesenen Wert einer Variablen zur Laufzeit zu ändern.

Feedback

War diese Seite hilfreich?