Überwachen von Variablen mit Überwachungsfenstern und QuickWatch

Während Sie debuggen, können Sie Überwachungsfenster und QuickWatch verwenden, um Variablen und Ausdrücke zu überwachen. Die Fenster sind nur während einer Debugsitzung verfügbar.

Überwachungsfenster können beim Debuggen mehrere Variablen gleichzeitig anzeigen. Das Dialogfeld QuickWatch zeigt jeweils eine einzelne Variable an und muss geschlossen werden, bevor das Debuggen fortgesetzt werden kann. Weitere Informationen zur Verwendung von QuickWatch finden Sie unter "Beobachten einer einzelnen Variablen oder eines einzelnen Ausdrucks mit QuickWatch".

Hinweis

Wenn Sie mit dem Debuggen von Code noch nicht fertig sind, sollten Sie das Debuggen für absolute Anfänger und Debugging-Techniken und Tools lesen, bevor Sie diesen Artikel durchgehen.

Beobachten von Variablen mit einem Überwachungsfenster

Sie können mehrere Überwachungsfenster öffnen und mehrere Variablen in einem Überwachungsfenster beobachten.

Wenn Sie beispielsweise eine Überwachung für die Werte von a, bund c im folgenden Code festlegen möchten:

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. Setzen Sie einen Haltepunkt auf der c = a + b; Zeile, indem Sie auf den linken Rand klicken, Debuggen>Breakpoint umschalten auswählen oder F9 drücken.

2. Starten Sie das Debuggen, indem Sie den grünen Start-Pfeil auswählen oder Debuggen>starten, oder drücken Sie F5. Die Ausführung wird am Haltepunkt angehalten.

3. ** Öffnen Sie ein Überwachungsfenster, indem Sie Debug>Windows>Watch>Watch 1 auswählen oder STRG+ALT+W>1 drücken.

   Sie können weitere Überwachungsfenster öffnen, indem Sie Windows 2, 3 oder 4 auswählen.

4. Wählen Sie im Überwachungsfenster eine leere Zeile aus, und geben Sie eine Variable aein. Führen Sie dasselbe für b und c aus.

   

5. Fahren Sie mit dem Debuggen fort, indem Sie "Debug>Step Into " auswählen oder F11 drücken, um fortzufahren. Die Variablenwerte im Überwachungsfenster ändern sich, während Sie die for Schleife durchlaufen.

Hinweis

Nur für C++

• Möglicherweise müssen Sie den Kontext eines Variablennamens oder einen Ausdruck qualifizieren, der einen Variablennamen verwendet. Der Kontext ist die Funktion, Quelldatei oder das Modul, in der sich eine Variable befindet. Wenn Sie den Kontext qualifizieren müssen, verwenden Sie die Syntax des Kontextoperators (C++) im Name-Feld im Überwachungsfenster.

• Sie können Registernamen und Variablennamen mithilfe von $<register name> oder @<register name> zum Namen im Überwachungsfenster hinzufügen. Weitere Informationen finden Sie unter Pseudovariables.

Verwenden von Ausdrücken in einem Überwachungsfenster

Sie können jeden gültigen Ausdruck beobachten, der vom Debugger in einem Überwachungsfenster erkannt wird.

Zum Beispiel können Sie für den Code im vorherigen Abschnitt den Durchschnitt der drei Werte ermitteln, indem Sie (a + b + c) / 3 im Uhren-Fenster eingeben.

Die Regeln zum Auswerten von Ausdrücken im Überwachungsfenster entsprechen im Allgemeinen den Regeln für die Auswertung von Ausdrücken in der Codesprache. Wenn ein Ausdruck einen Syntaxfehler aufweist, erwarten Sie denselben Compilerfehler wie im Code-Editor. Ein Tippfehler im vorherigen Ausdruck erzeugt z. B. diesen Fehler im Überwachungsfenster :

Im Watch-Fenster wird möglicherweise ein Kreis mit zwei wellenförmigen Linien angezeigt. Dieses Symbol bedeutet, dass der Debugger den Ausdruck aufgrund einer potenziellen Threadabhängigkeit nicht auswertet. Für die Auswertung des Codes müssen andere Threads in Ihrer App vorübergehend ausgeführt werden, da Sie jedoch im Unterbrechungsmodus sind, werden alle Threads in Ihrer App in der Regel beendet. Wenn andere Threads vorübergehend ausgeführt werden können, kann dies unerwartete Auswirkungen auf den Zustand Ihrer App haben, und der Debugger ignoriert möglicherweise Ereignisse wie Haltepunkte und Ausnahmen für diese Threads.

Suchen im Überwachungsfenster

Sie können mithilfe der Suchleiste über jedem Fenster nach Schlüsselwörtern in den Spalten "Name", "Wert" und "Typ" des Überwachungsfensters suchen. Drücken Sie die EINGABETASTE, oder wählen Sie einen der Pfeile aus, um eine Suche auszuführen. Um eine laufende Suche abzubrechen, wählen Sie in der Suchleiste das Symbol "x" aus.

Verwenden Sie die linke und rechte Pfeiltaste (Umschalt+F3 bzw. F3), um zwischen gefundenen Übereinstimmungen zu navigieren.

Um ihre Suche mehr oder weniger gründlich zu gestalten, verwenden Sie oben im Überwachungsfenster die Dropdownliste "Tiefer suchen", um auszuwählen, wie viele Ebenen tief Sie in geschachtelte Objekte suchen möchten.

Pin-Eigenschaften im Überwachungsfenster

Hinweis

Dieses Feature wird in .NET Core 3.0 oder höher unterstützt.

Sie können Objekte schnell anhand ihrer Eigenschaften im Überwachungsfenster mit dem Tool " Anheftbare Eigenschaften" überprüfen. Wenn Sie dieses Tool verwenden möchten, zeigen Sie mit der Maus auf eine Eigenschaft, und wählen Sie das eingeblendete Pinsymbol aus. Alternativ klicken Sie mit der rechten Maustaste auf die betreffende Eigenschaft, und wählen Sie im Kontextmenü die Option Member als Favorit anheften aus. Mit dieser Aktion wird diese Eigenschaft oben in der Eigenschaftenliste des Objekts eingeblendet, und der Eigenschaftsname und -wert wird in der Spalte " Wert " angezeigt. Wenn Sie eine Eigenschaft loslösen möchten, klicken Sie noch einmal auf das Anheftsymbol, oder klicken Sie im Kontextmenü auf die Option Member als Favorit lösen.

Sie können zwischen verschiedenen Darstellungen der Eigenschaftsnamen umschalten und nicht angepinnte Eigenschaften herausfiltern, wenn Sie die Eigenschaftenliste des Objekts im Watch-Fenster anzeigen. Sie können auf beide Optionen zugreifen, indem Sie die Schaltflächen in der Symbolleiste oberhalb des Überwachungsfensters auswählen.

Aktualisieren von Überwachungswerten

Ein Aktualisierungssymbol (Kreispfeil) wird möglicherweise im Überwachungsfenster angezeigt, wenn ein Ausdruck ausgewertet wird. Das Aktualisierungssymbol gibt einen Fehler oder einen Wert an, der nicht mehr aktuell ist.

Um den Wert zu aktualisieren, wählen Sie das Aktualisierungssymbol aus, oder drücken Sie die LEERTASTE. Der Debugger versucht, den Ausdruck neu zu bewerten. Möglicherweise möchten Sie den Ausdruck jedoch nicht neu bewerten, je nachdem, warum der Wert nicht ausgewertet wurde.

Zeigen Sie mit der Maus auf das Aktualisierungssymbol, oder zeigen Sie die Spalte "Wert " aus dem Grund an, warum der Ausdruck nicht ausgewertet wurde. Gründe sind folgende:

• Ein Fehler trat beim Bewerten des Ausdrucks auf, wie im vorherigen Beispiel. Ein Timeout kann auftreten, oder eine Variable ist außerhalb des Gültigkeitsbereichs.

• Der Ausdruck verfügt über einen Funktionsaufruf, der einen Nebeneffekt in der App auslösen kann. Siehe Ausdrucks-Nebenwirkungen.

• Die automatische Auswertung von Eigenschaften und impliziten Funktionsaufrufen ist deaktiviert.

Wenn das Aktualisierungssymbol angezeigt wird, weil die automatische Auswertung von Eigenschaften und impliziten Funktionsaufrufen deaktiviert ist, können Sie die Debugeinstellung über das Menü ">" aktualisieren.

So veranschaulichen Sie die Verwendung des Aktualisierungssymbols:

1. Deaktivieren Sie im Bereich "Extras" (oder "Debug") unter dem Abschnitt "Alle EinstellungenDebuggenAllgemein" das Kontrollkästchen "Aktivieren der Eigenschaftenauswertung und anderer impliziter Funktionsaufrufe.

2. Geben Sie den folgenden Code ein, und legen Sie im Überwachungsfenster eine Überwachung für die list.Count Eigenschaft fest.

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

3. Starten Sie das Debuggen. Das Überwachungsfenster zeigt etwa die folgende Meldung an:

   

4. Um den Wert zu aktualisieren, wählen Sie das Aktualisierungssymbol aus, oder drücken Sie die LEERTASTE. Der Debugger wertet den Ausdruck neu aus.

Ausdrucks-Nebenwirkungen

Die Auswertung einiger Ausdrücke kann den Wert einer Variablen ändern oder sich auf den Zustand Ihrer App auswirken. Die Auswertung des folgenden Ausdrucks ändert z. B. den Wert von var1:

var1 = var2

Dieser Code kann zu einem Nebeneffekt führen. Nebeneffekte können das Debuggen erschweren, indem sie die Funktionsweise Ihrer App ändern.

Ein Ausdruck mit Nebenwirkungen wird nur einmal ausgewertet, wenn Sie ihn zum ersten Mal eingeben. Danach wird der Ausdruck im Überwachungsfenster ausgegraut angezeigt, und weitere Auswertungen sind deaktiviert. In der QuickInfo- oder Wert-Spalte wird erläutert, dass der Ausdruck einen Nebeneffekt verursacht. Sie können die Erneute Auswertung erzwingen, indem Sie das Aktualisierungssymbol auswählen, das neben dem Wert angezeigt wird.

Eine Möglichkeit, die Kennzeichnung der Nebenwirkungen zu verhindern, besteht darin, die automatische Funktionsauswertung zu deaktivieren. Deaktivieren Sie im Bereich "Extras" (oder "Debug") unter dem Abschnitt "Alle EinstellungenDebuggenAllgemein" das Kontrollkästchen "Aktivieren der Eigenschaftenauswertung und anderer impliziter Funktionsaufrufe.

Nur für C# können Sie, wenn die Auswertung von Eigenschaften oder impliziten Funktionsaufrufen deaktiviert ist, die Auswertung erzwingen, indem Sie den Formatmodifizierer ac zu einem Variablennamen im Überwachungsfenster hinzufügen. Siehe Formatbezeichner in C#.

Verwenden von Objekt-IDs im Überwachungsfenster (C# und Visual Basic)

Manchmal möchten Sie das Verhalten eines bestimmten Objekts beobachten. So können Sie beispielsweise ein Objekt nachverfolgen, auf das von einer lokalen Variablen verwiesen wird, nachdem diese Variable nicht mehr im Bereich war. In C# und Visual Basic können Sie Objekt-IDs für bestimmte Instanzen von Referenztypen erstellen und im Überwachungsfenster und unter Haltepunktbedingungen verwenden. Die Objekt-ID wird von den Debugdiensten der Common Language Runtime (CLR) generiert und dem Objekt zugeordnet.

Hinweis

Objekt-IDs erstellen schwache Verweise, die nicht verhindern, dass das Objekt vom Garbage Collector eingesammelt wird. Sie sind nur für die aktuelle Debugsitzung gültig.

Im folgenden Code erstellt die MakePerson() Methode eine Person mithilfe einer lokalen Variable:

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

Um den Namen des Person im DoSomething()-Methode zu ermitteln, können Sie im Person einen Verweis auf die Objekt-ID hinzufügen.

1. Legen Sie einen Haltepunkt im Code fest, nachdem das Person Objekt erstellt wurde.

2. Starten Sie das Debuggen.

3. Wenn die Ausführung am Haltepunkt angehalten wird, öffnen Sie das Fenster "Lokal", indem Sie">> auswählen.

4. Klicken Sie im Fenster "Lokal" mit der rechten Maustaste auf die Person Variable, und wählen Sie " Objekt-ID erstellen" aus.

   Im $" sollte ein Dollarzeichen () plus eine Zahl angezeigt werden, bei der es sich um die Objekt-ID handelt.

5. Fügen Sie die Objekt-ID zum Überwachungsfenster hinzu, indem Sie mit der rechten Maustaste auf die Objekt-ID klicken und "Überwachung hinzufügen" auswählen.

6. Legen Sie einen anderen Haltepunkt in der DoSomething() Methode fest.

7. Fahren Sie mit dem Debuggen fort. Wenn die Ausführung in der DoSomething() Methode angehalten wird, zeigt das Überwachungsfenster das Person Objekt an.

   Wenn Sie die Eigenschaften des Objekts, wie z. B. Person.Name, anzeigen möchten, müssen Sie die Eigenschaftenauswertung aktivieren.

   Aktivieren Sie im Bereich Extras (oder Debugoptionen) > unter dem Abschnitt "Alle Einstellungen>>" das Kontrollkästchen "Eigenschaftenauswertung aktivieren" und andere implizite Funktionsaufrufe.

Dynamische Ansicht und das Überwachungsfenster

Einige Skriptsprachen (z. B. JavaScript oder Python) verwenden dynamisches oder Duck-Typing, und .NET Version 4.0 und höher unterstützt Objekte, die in den normalen Debug-Fenstern schwer zu beobachten sind.

Im Überwachungsfenster werden diese Objekte als dynamische Objekte angezeigt, die aus Typen erstellt werden, die die IDynamicMetaObjectProvider Schnittstelle implementieren. Dynamische Objektknoten zeigen die dynamischen Elemente der dynamischen Objekte an, lassen jedoch keine Bearbeitung der Memberwerte zu.

Um die Werte der dynamischen Ansicht zu aktualisieren, wählen Sie das Aktualisierungssymbol neben dem dynamischen Objektknoten aus.

Um nur die dynamische Ansicht für ein Objekt anzuzeigen, fügen Sie nach dem Namen des dynamischen Objekts im Überwachungsfenster einen dynamischen Formatbezeichner hinzu:

• Für C#: ObjectName, dynamic
• Für Visual Basic: $dynamic, ObjectName

Hinweis

• Der C#-Debugger wertet die Werte in der dynamischen Ansicht nicht automatisch neu, wenn Sie zur nächsten Codezeile wechseln.
• Der Visual Basic-Debugger aktualisiert automatisch Ausdrücke, die über die dynamische Ansicht hinzugefügt werden.
• Die Auswertung der Elemente einer dynamischen Ansicht kann Nebenwirkungen haben.

Um eine neue Überwachungsvariable einzufügen, die ein Objekt als ein dynamisches Objekt castet:

1. Klicken Sie mit der rechten Maustaste auf ein beliebiges untergeordnetes Element einer dynamischen Ansicht.
2. Wählen Sie "Überwachung hinzufügen" aus. Das object.name wird zu ((dynamic) object).name und erscheint in einem neuen Überwachungsfenster.

Der Debugger fügt dem Fenster "Autos" auch einen untergeordneten Knoten "Dynamische Ansicht" des Objekts hinzu. Wählen Sie zum Öffnen des Fensters "Autos" beim Debuggendie Option "Windows>Autos>" aus.

Die dynamische Ansicht verbessert auch das Debuggen für COM-Objekte. Wenn der Debugger zu einem COM-Objekt wechselt, das in System.__ComObject eingeschlossen wird, wird ein Dynamischer Ansichtsknoten für das Objekt hinzugefügt.

Beobachten einer einzelnen Variablen oder eines ausdrucks mit QuickWatch

Sie können QuickWatch verwenden, um eine einzelne Variable zu beobachten.

Zum Beispiel für den folgenden Code:

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

Um die a Variable zu beobachten,

1. Legen Sie einen Haltepunkt in der a = a + b; Zeile fest.

2. Starten Sie das Debuggen. Die Ausführung wird am Haltepunkt angehalten.

3. Wählen Sie die Variable a im Code aus.

4. Wählen Sie Debug>QuickWatch aus, drücken Sie Umschalt+, oder klicken Sie mit der rechten Maustaste und wählen Sie QuickWatch.

   Das Dialogfeld "QuickWatch " wird angezeigt. Die a Variable befindet sich im Ausdrucksfeld mit dem Wert1.

   

5. Wenn Sie einen Ausdruck mithilfe der Variablen auswerten möchten, geben Sie einen Ausdruck ein, z a + b . B. im Feld "Ausdruck ", und wählen Sie " Neu bewerten" aus.

   

6. Um die Variable oder den Ausdruck aus QuickWatch zum Überwachungsfenster hinzuzufügen, wählen Sie "Überwachung hinzufügen" aus.

7. Wählen Sie "Schließen" aus, um das QuickWatch-Fenster zu schließen. (QuickWatch ist ein modales Dialogfeld, sodass Sie das Debuggen nicht fortsetzen können, solange es geöffnet ist.)

8. Fahren Sie mit dem Debuggen fort. Sie können die Variable im Überwachungsfenster beobachten.

KI-Unterstützung erhalten

Wenn Sie Copilot haben, können Sie KI-Unterstützung erhalten, während Sie Variablen in den Überwachungsfenstern betrachten. Klicken Sie mit der rechten Maustaste auf eine Variable und verwenden Sie die Schaltfläche Ask Copilot In diesem Szenario kennt Copilot bereits den Kontext für Ihre Frage, damit Sie im Chat nicht selbst Kontext bereitstellen müssen. Weitere Informationen finden Sie unter Debuggen mit Copilot.

Verwandte Inhalte

• Was ist das Debuggen?
• Debugtechniken und Tools
• Erster Einblick in das Debuggen
• Debuggerfenster