Überwachen von Variablen mit Überwachungsfenstern und Schnellüberwachung

Beim Debuggen können Sie Fenster des Typs Überwachen und Schnellüberwachung verwenden, um Variablen und Ausdrücke zu überwachen. Die Fenster sind nur während einer Debugsitzung verfügbar.

In Fenstern des Typs Überwachen können während des Debuggens mehrere Variablen gleichzeitig angezeigt werden. Im Dialogfeld Schnellüberwachung wird jeweils eine einzelne Variable angezeigt. Dieses Dialogfeld 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 zum ersten Mal versuchen, Code zu debuggen, sollten Sie Debuggen für Einsteiger sowie Debugverfahren und -tools lesen, bevor Sie diesen Artikel durchgehen.

Beobachten von Variablen mit einem Überwachungsfenster

Sie können mehrere Fenster des Typs Überwachen öffnen und mehrere Variablen in einem Überwachen-Fenster beobachten.

Wenn Sie beispielsweise eine Überwachung der Werte von a, b und c im folgenden Code festlegen möchten, gehen Sie folgendermaßen vor:

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. Legen Sie einen Haltepunkt in der Zeile c = a + b; fest. Dazu klicken Sie auf den linken Rand und wählen Debuggen>Haltepunkt ein/aus aus, oder Sie drücken F9.

2. Starten Sie das Debuggen. Dazu wählen Sie den grünen Pfeil für Starten oder Debuggen>Debuggen starten aus, oder drücken Sie F5. Die Ausführung wird am Haltepunkt angehalten.

3. Öffnen Sie ein Fenster des Typs Überwachen. Dazu wählen Sie Debuggen>Fenster>Überwachen>Überwachen 1 aus, oder drücken Sie STRG+ALT+W>1.

   Sie können weitere Fenster des Typs Überwachen öffnen, indem Sie die Fenster 2, 3 oder 4 auswählen.

4. Wählen Sie im Fenster Überwachen eine leere Zeile aus, und geben Sie Variable a ein. Führen Sie die gleichen Schritte für b und c aus.

   

5. Setzen Sie das Debuggen fort, indem Sie nach Bedarf Debuggen>Einzelschritt auswählen oder F11 drücken, um fortzufahren. Die Variablenwerte im Fenster Überwachen ändern sich, während Sie die for-Schleife durchlaufen.

Hinweis

Nur für C++:

• Möglicherweise müssen Sie den Kontext eines Variablennamens oder eines Ausdrucks, der einen Variablennamen verwendet, qualifizieren. Mit dem Kontext sind die Funktion, die Quelldatei oder das Modul gemeint, in der bzw. dem eine Variable enthalten ist. Wenn Sie den Kontext qualifizieren müssen, verwenden Sie die Syntax des Kontextoperators (C++) für Name im Fenster Überwachen.

• Sie können Registernamen und Variablennamen mithilfe von $<Registername> oder @<Registername>zu Name im Fenster Überwachen hinzufügen. Weitere Informationen finden Sie unter Pseudovariables.

Verwenden von Ausdrücken in einem Überwachungsfenster

Sie können jeden vom Debugger erkannten gültigen Ausdruck in einem Überwachen-Fenster beobachten.

Beispielsweise können Sie für den im vorherigen Abschnitt gezeigten Code den Mittelwert der drei Werte ermitteln, indem Sie (a + b + c) / 3 im Fenster Überwachen eingeben:

Die Regeln zum Auswerten von Ausdrücken im Fenster Überwachen entsprechen im Allgemeinen den Regeln zum Auswerten von Ausdrücken in der Codesprache. Wenn ein Ausdruck einen Syntaxfehler aufweist, können Sie den gleichen Compilerfehler wie im Code-Editor erwarten. Beispielsweise erzeugt ein Tippfehler im vorherigen Ausdruck den folgenden Fehler im Fenster Überwachen:

Im Fenster Überwachen wird möglicherweise ein Kreis mit zwei Wellenlinien angezeigt. Dieses Symbol bedeutet, dass der Debugger den Ausdruck aufgrund einer möglichen threadübergreifenden Abhängigkeit nicht auswertet. Für die Auswertung des Codes müssen andere Threads in der App vorübergehend ausgeführt werden. Da Sie sich aber im Unterbrechungsmodus befinden, sind alle Threads in der App normalerweise angehalten. Wenn die vorübergehende Ausführung anderer Threads zugelassen wird, kann dies unerwartete Auswirkungen auf den Zustand der App haben, und der Debugger ignoriert möglicherweise Ereignisse wie z. B. Haltepunkte und Ausnahmen für diese Threads.

Suchen im Überwachungsfenster

Sie können mithilfe der Suchleiste oberhalb der einzelnen Fenster nach Schlüsselwörtern in den Spalten „Name“, „Wert“ und „Typ“ im Fenster Überwachen suchen. Drücken Sie die EINGABETASTE, oder wählen Sie einen der Pfeile aus, um eine Suche auszuführen. Zum Abbrechen einer laufenden Suche wählen Sie das Symbol „x“ in der Suchleiste aus.

Mit den Pfeilen nach links und rechts (UMSCHALT+F3 bzw. F3) können Sie zwischen gefundenen Übereinstimmungen navigieren.

Wenn Sie die Suche mehr oder weniger gründlich durchführen möchten, verwenden Sie die Dropdownliste Suchtiefe am oberen Rand des Fensters Überwachen, um auszuwählen, wie viele Ebenen tief in geschachtelten Objekten gesucht werden soll.

Anheften von Eigenschaften im Überwachungsfenster

Hinweis

Diese Funktion wird in .NET Core 3.0 oder höher unterstützt.

Mit dem Tool Anheftbare Eigenschaften können Sie Objekte schnell anhand ihrer Eigenschaften im Überwachungsfenster überprüfen. Um dieses Tool zu verwenden, zeigen Sie auf eine Eigenschaft, und wählen Sie das daraufhin angezeigte Anheften-Symbol aus. Sie können auch mit der rechten Maustaste klicken und im resultierenden Kontextmenü die Option Member als Favorit anheften auswählen. Dadurch wird diese Eigenschaft in der Eigenschaftenliste des Objekts an oberste Stelle gesetzt, und der Eigenschaftsname und -wert wird in der Spalte Wert angezeigt. Wenn Sie eine Eigenschaft lösen möchten, wählen Sie das Anheften-Symbol erneut aus, oder wählen Sie im Kontextmenü die Option Member als Favorit lösen aus.

Sie können beim Anzeigen der Eigenschaftenliste des Objekts im Überwachungsfenster auch Eigenschaftsnamen umschalten und nicht angeheftete Eigenschaften herausfiltern. Sie können auf beide Optionen zugreifen, indem Sie die Schaltflächen auf der Symbolleiste oberhalb des Überwachungsfensters auswählen.

Aktualisieren von Überwachungswerten

Beim Auswerten eines Ausdrucks wird möglicherweise ein Aktualisierungssymbol (kreisförmiger Pfeil) im Fenster Überwachen angezeigt. Das Aktualisierungssymbol weist auf einen Fehler oder einen veralteten Wert hin.

Klicken Sie zum Aktualisieren des Werts auf das Aktualisierungssymbol, oder drücken Sie die LEERTASTE. Der Debugger versucht, den Ausdruck neu auszuwerten. Je nachdem, warum der Wert nicht ausgewertet wurde, kann es sein, dass Sie den Ausdruck nicht neu auswerten wollen oder können.

Zeigen Sie auf das Aktualisierungssymbol, oder sehen Sie in der Spalte Wert nach, um zu erfahren, warum der Ausdruck nicht ausgewertet wurde. Dies kann u.a. folgende Gründe haben:

• Beim Auswerten des Ausdrucks ist ein Fehler aufgetreten (wie im vorherigen Beispiel). Möglicherweise ist ein Timeout aufgetreten, oder eine Variable liegt außerhalb des gültigen Bereichs.

• Der Ausdruck enthält einen Funktionsaufruf, der einen Nebeneffekt in der App auslösen könnte. Informationen dazu finden Sie unter Nebeneffekte von Ausdrücken.

• 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 diese Option aktivieren, indem Sie Eigenschaftenauswertung und andere implizite Funktionsaufrufe zulassen unter Extras>Optionen>Debuggen>Allgemein auswählen.

Die Verwendung des Aktualisierungssymbols kann mit folgenden Schritten veranschaulicht werden:

1. Deaktivieren Sie unter Extras>Optionen>Debuggen>Allgemein das Kontrollkästchen Eigenschaftenauswertung und andere implizite Funktionsaufrufe zulassen.

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

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

3. Beginnen Sie mit dem Debuggen. Im Fenster Überwachen wird in etwa die folgende Meldung angezeigt:

   

4. Klicken Sie zum Aktualisieren des Werts auf das Aktualisierungssymbol, oder drücken Sie die LEERTASTE. Der Debugger wertet den Ausdruck erneut aus.

Nebeneffekte von Ausdrücken

Die Auswertung bestimmter Ausdrücke kann zur Änderung des Werts einer Variablen führen oder sich anderweitig auf den Zustand der App auswirken. Die Auswertung des folgenden Ausdrucks ändert beispielsweise den Wert von var1:

var1 = var2

Dieser Code kann einen Nebeneffekt verursachen. Nebeneffekte können das Debuggen erschweren, da sie die Funktionsweise der App ändern.

Ein Ausdruck mit Nebeneffekten wird nur bei der ersten Eingabe ausgewertet. Danach ist der Ausdruck im Fenster Überwachen ausgegraut, und weitere Auswertungen sind deaktiviert. In der QuickInfo oder der Spalte Wert wird erklärt, dass der Ausdruck einen Nebeneffekt bewirkt. Sie können eine erneute Auswertung erzwingen, indem Sie auf das Aktualisierungssymbol klicken, das neben dem Wert angezeigt wird.

Eine Möglichkeit, die Angabe von Nebeneffekten zu verhindern, ist das Deaktivieren der automatischen Funktionsauswertung. Deaktivieren Sie unter Extras>Optionen>Debuggen>Allgemein die Option Eigenschaftenauswertung und andere implizite Funktionsaufrufe zulassen.

Nur für C#: Wenn die Auswertung von Eigenschaften oder impliziten Funktionsaufrufen deaktiviert ist, können Sie die Auswertung erzwingen, indem Sie den ac-Formatmodifizierer zu einer Variablen unter Name im Fenster Überwachen hinzufügen. Weitere Informationen finden Sie unter Formatieren von Spezifizierern in C#.

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

Manchmal möchten Sie das Verhalten eines bestimmten Objekts beobachten. Beispielsweise möchten Sie ein Objekt nachverfolgen, auf das eine lokale Variable verweist, nachdem diese Variable den Gültigkeitsbereich verlassen hat. In C# und Visual Basic können Sie Objekt-IDs für bestimmte Instanzen von Verweistypen erstellen und diese im Fenster Überwachen und in Haltepunktbedingungen verwenden. Die Objekt-ID wird von den Debugdiensten der CLR (Common Language Runtime) generiert und dem Objekt zugeordnet.

Hinweis

Objekt-IDs erstellen schwache Verweise, die nicht verhindern, dass das Objekt in die Garbage Collection aufgenommen wird. Sie gelten nur für die aktuelle Debugsitzung.

Im folgenden Code erstellt die MakePerson()-Methode eine Person anhand 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 von Person in der DoSomething()-Methode zu ermitteln, können Sie im Fenster Überwachen einen Verweis auf die Objekt-ID von Person hinzufügen.

1. Legen Sie im Code nach der Erstellung des Person-Objekts einen Haltepunkt fest.

2. Beginnen Sie mit dem Debuggen.

3. Wenn die Ausführung am Haltepunkt angehalten wird, öffnen Sie das Fenster Lokal. Dazu wählen Sie Debuggen>Fenster>Lokal aus.

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

   Es sollte ein Dollarzeichen ( $ ) mit einer Nummer im Fenster Lokal angezeigt werden. Dies ist die Objekt-ID.

5. Fügen Sie die Objekt-ID dem Fenster Überwachen 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. Debuggen fortsetzen. Wenn die Ausführung in der DoSomething()-Methode anhält, wird im Fenster Überwachen das Person-Objekt angezeigt.

   Hinweis

   Wenn Sie die Eigenschaften des Objekts anzeigen möchten (z. B. Person.Name), müssen Sie die Eigenschaftenauswertung aktivieren. Dazu wählen Sie Extras>Optionen>Debuggen>Allgemein>Eigenschaftenauswertung und andere implizite Funktionsaufrufe zulassen aus.

Dynamische Ansicht und das Überwachungsfenster

Einige Skriptsprachen (z. B. JavaScript oder Python) verwenden eine dynamische Typzuweisung oder das Duck-Typing, und .NET-Sprachen ab Version 4.0 unterstützen Objekte, die in den normalen Debugfenstern nur schwer beobachtet werden können.

Im Fenster Überwachen werden diese Objekte als dynamische Objekte angezeigt, die aus Typen erstellt werden, die die IDynamicMetaObjectProvider-Schnittstelle implementieren. Knoten für dynamische Objekte zeigen die dynamischen Member der dynamischen Objekte an, ermöglichen jedoch keine Bearbeitung der Memberwerte.

Um Werte im Fenster Dynamische Ansicht zu aktualisieren, wählen Sie das Aktualisierungssymbol neben dem Knoten für dynamische Objekte aus.

Wenn Sie nur das Fenster Dynamische Ansicht für ein Objekt anzeigen möchten, fügen Sie einen dynamic-Formatspezifizierer hinter dem Namen des dynamischen Objekts im Fenster Überwachen hinzu:

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

Hinweis

• Der C#-Debugger wertet die Werte im Fenster Dynamische Ansicht nicht automatisch erneut aus, wenn Sie zur nächsten Codezeile wechseln.
• Der Visual Basic-Debugger führt automatisch eine Aktualisierung für Ausdrücke durch, die über das Fenster Dynamische Ansicht hinzugefügt werden.
• Wenn Sie die Member einer dynamischen Ansicht auswerten, kann das zu Nebenwirkungen führen.

Führen Sie die folgenden Schritte aus, um eine neue Überwachungsvariable einzufügen, die ein Objekt in ein dynamisches Objekt umwandelt:

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

Der Debugger fügt außerdem dem Fenster Auto einen untergeordneten Knoten Dynamische Ansicht des Objekts hinzu. Um das Fenster Auto zu öffnen, wählen Sie während des Debuggens die Option Debuggen>Fenster>Auto aus.

Die dynamische Ansicht verbessert auch das Debuggen für COM-Objekte. Wenn der Debugger ein in System.__ComObject umschlossenes COM-Objekt erreicht, fügt er einen Knoten Dynamische Ansicht für das Objekt hinzu.

Beobachten einer einzelnen Variablen oder eines Ausdrucks mit der Schnellüberwachung

Sie können die Schnellüberwachung zum Beobachten einer einzelnen Variablen verwenden.

Sehen Sie sich beispielsweise den folgenden Code an:

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

Zum Beobachten der Variablen a gehen Sie folgendermaßen vor:

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

2. Beginnen Sie mit dem Debuggen. Die Ausführung wird am Haltepunkt angehalten.

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

4. Wählen Sie Debuggen>Schnellüberwachung aus, drücken Sie UMSCHALT+F9, oder klicken Sie mit der rechten Maustaste, und wählen Sie Schnellüberwachung aus.

   Das Dialogfeld Schnellüberwachung wird angezeigt. Die Variable a befindet sich im Feld Ausdruck und weist als Wert die Zahl 1 auf.

   

5. Wenn Sie einen Ausdruck mithilfe der Variablen auswerten möchten, geben Sie einen Ausdruck wie a + b in das Feld Ausdruck ein, und wählen Sie Neu auswerten aus.

   

6. Wenn Sie die Variable oder den Ausdruck aus Schnellüberwachung dem Fenster Überwachen hinzufügen möchten, wählen Sie Überwachung hinzufügen aus.

7. Wählen Sie Schließen aus, um das Fenster Schnellüberwachung zu schließen. (Schnellüberwachung ist ein modales Dialogfeld, d. h., Sie können den Debugvorgang nicht fortsetzen, solange es geöffnet ist.)

8. Debuggen fortsetzen. Sie können die Variable im Fenster Überwachen beobachten.

Zugehöriger Inhalt

• Was bedeutet „Debuggen“?
• Debugging techniques and tools (Debugverfahren und -tools)
• Ein erster Blick auf den Visual Studio-Debugger
• Debuggerfenster