Ein erster Blick auf den Visual Studio-Debugger

Dieser Artikel stellt eine Einführung in die Debuggertools dar, die in Visual Studio enthalten sind. Wenn Sie Ihre App in Visual Studio debuggen, bedeutet dies in der Regel, dass Sie Ihre Anwendung mit dem angefügten Debugger (also im Debugmodus) ausführen. Wenn Sie dies machen, bietet der Debugger viele Möglichkeiten zum Ermitteln des Status Ihres Codes während der Ausführung. Sie können Ihren Code schrittweise durchlaufen und die Werte prüfen, die in Variablen gespeichert sind, Sie können die Überwachung von Variablen festlegen, um zu sehen, wenn sich Werte ändern, und Sie können unter anderem den Ausführungspfad Ihres Codes prüfen. Wenn Sie zum ersten Mal versuchen, Code zu debuggen, sollten Sie Debuggen für Einsteiger lesen, bevor Sie diesen Artikel durchgehen. Wenn Sie versuchen, eine bestimmte Aufgabe auszuführen und wissen möchten, welches Feature sie verwenden sollen, nutzen Sie das Suchtool für Debuggerfeatures. Informationen zum Testen des KI-gestützten Debuggings finden Sie unter Debuggen mit Copilot.

Die hier beschriebenen Features gelten für C#, C++, Visual Basic, JavaScript und andere von Visual Studio unterstützten Programmiersprachen (sofern nicht anderweitig angegeben).

Festlegen eines Breakpoints und Starten des Debuggers

Breakpoints sind ein nützliches Feature, wenn Ihnen die Codezeile oder der Codeabschnitt bekannt ist, die bzw. den Sie zur Laufzeit genauer untersuchen möchten. Weitere Informationen zu den verschiedenen verfügbaren Typen von Breakpoints, wie z. B. bedingte Breakpoints und Funktionsbreakpoints, finden Sie unter Verwenden von Haltepunkten im Visual Studio-Debugger.

Sie müssen Ihre App mit dem an den App-Prozess angefügten Debugger starten, um diese zu debuggen. Dazu ist Folgendes erforderlich:

• Drücken Sie F5 (Debuggen > Debuggen starten). Diese Methode wird am häufigsten verwendet.

Bisher haben Sie jedoch wahrscheinlich noch keine Breakpoints für die Untersuchung Ihres App-Codes festgelegt, deshalb werden Sie dies tun, bevor Sie mit dem Debuggen beginnen. Haltepunkte sind eine einfache und wichtige Funktion zum zuverlässigen Debuggen. Ein Haltepunkt gibt an, wo Visual Studio im ausgeführten Code angehalten werden soll. So können Sie einen Blick auf die Werte von Variablen oder das Speicherverhalten werfen oder überprüfen, ob eine Verzweigung im Code ausgeführt wird.

Wenn Sie eine Datei im Code-Editor geöffnet haben, können Sie einen Breakpoint festlegen, indem Sie auf den Rand links neben einer Codezeile klicken.

Drücken Sie die Taste F5 (Debuggen > Debuggen starten), oder klicken Sie in der Symbolleiste „Debuggen“ auf die Schaltfläche Debuggen starten. Der Debugger wird anschließend bis zum ersten Breakpoint ausgeführt. Wenn die App noch nicht ausgeführt wird, kann der Debugger durch Drücken der Taste F5 gestartet werden und hält am ersten Breakpoint an.

Navigieren durch Code im Debugger mithilfe von Schrittbefehlen

Für die meisten Befehle gibt es Tastenkombinationen, da Sie mit diesen schneller durch den Code Ihrer App navigieren können. (Entsprechende Befehle wie Menübefehle werden in Klammern angezeigt.) Weitere Informationen zur Verwendung der Schrittbefehle finden Sie unter Navigieren durch Code im Debugger.

Drücken Sie F11 (Debuggen > Einzelschritt), um Ihre App mit angefügtem Debugger zu starten. Durch Drücken der Taste F11 wird der Befehl Einzelschritt ausgeführt, und die App wird Anweisung für Anweisung ausgeführt. Wenn Sie die App mit F11 starten, hält der Debugger bei der ersten Anweisung an, die ausgeführt wird.

Der gelbe Pfeil stellt die Anweisung dar, an der der Debugger angehalten hat. An der gleichen Stelle wird auch die Ausführung der App unterbrochen (diese Anweisung wurde noch nicht ausgeführt).

Das Drücken der Taste F11 bietet eine gute Möglichkeit, den Ausführungsablauf am ausführlichsten zu überprüfen. (Es werden auch einige andere Optionen vorgestellt, mit denen Sie den Code schneller durchlaufen können.) Standardmäßig überspringt der Debugger Nichtbenutzercode (weitere Einzelheiten hierzu finden Sie unter Nur eigenen Code).

Prozedurschritt im Code zum Überspringen von Funktionen

In einer Codezeile, die eine Funktion oder einen Methodenaufruf enthält, können Sie F10 (Debuggen > Prozedurschritt) anstelle von F11 verwenden.

Durch Drücken der Taste F10 fährt der Debugger in Ihrem App-Code fort, ohne dass Funktionen oder Methoden schrittweise ausgeführt werden (der Code wird immer noch ausgeführt). Sie können Code überspringen, der für Sie nicht relevant ist, indem Sie F10 drücken. Dadurch gelangen Sie schnell zum relevanten Code. Weitere Informationen zur Verwendung der Schrittbefehle finden Sie unter Navigieren durch Code im Debugger.

Schnelles Ausführen bis zu einer bestimmten Stelle im Code mithilfe der Maus

Die Verwendung der Schaltfläche Run to Click (Ausführung bis Klick) ist mit dem Festlegen eines temporären Breakpoints vergleichbar. Dieser Befehl ist zudem nützlich, wenn Sie eine sichtbare Region Ihres App-Codes schnell durchlaufen möchten. Sie können Ausführung bis Klick in jeder geöffneten Datei verwenden. Weitere Informationen zu diesem Feature und ähnlichen Navigationsfeatures finden Sie unter Ausführen bis zu einer bestimmten Position im Code.

Zeigen Sie im Debugger auf eine Codezeile, bis die Schaltfläche Ausführung bis Klick (Ausführung bis hier) auf der linken Seiten angezeigt wird.

Klicken Sie auf die Schaltfläche Ausführung bis Klick (Ausführung bis hier ausführen). Der Debugger wechselt zu der Codezeile, auf die Sie geklickt haben.

Fortsetzen des Debuggers außerhalb der aktuellen Funktion

In einigen Fällen möchten Sie Ihre Debugsitzung fortsetzen, der Debugger soll die aktuelle Funktion jedoch durchlaufen.

Drücken Sie UMSCHALT + F11 (alternativ: Debuggen > Ausführen bis Rücksprung).

Mit diesem Befehl wird die Ausführung der App so lange fortgesetzt (und der Debugger weiter ausgeführt), bis die aktuelle Funktion wieder ausgeführt wird.

Ausführen bis Cursor

Wenn Sie Code bearbeiten (anstatt ihn im Debugger anzuhalten), klicken Sie mit der rechten Maustaste auf eine Codezeile in Ihrer App, und wählen Sie dann Ausführen bis Cursor aus (oder drücken Sie STRG + F10). Dadurch wird das Debuggen gestartet und ein temporärer Breakpoint in der aktuellen Codezeile festgelegt. Weitere Informationen zu diesem Feature und ähnlichen Navigationsfeatures finden Sie unter Ausführen bis zu einer bestimmten Position im Code.

Wenn Sie Breakpoints festgelegt haben, hält der Debugger am ersten Breakpoint an, den er erreicht.

Drücken Sie F5, bis Sie die Codezeile erreichen, für die Sie Ausführen bis Cursor festgelegt haben.

Dieser Befehl ist nützlich, wenn Sie Code bearbeiten und schnell einen temporären Breakpoint festlegen möchten, während gleichzeitig der Debugger gestartet wird.

Schnelles Neustarten Ihrer App

Klicken Sie in der Symbolleiste „Debuggen“ auf die Schaltfläche Neustarten (oder drücken Sie STRG + Shift + F5).

Durch das Klicken auf Neu starten sparen Sie im Vergleich zum Beenden der App und dem erneuten Starten des Debuggers Zeit. Der Debugger hält am ersten Breakpoint an, der bei der Codeausführung erreicht wird.

Wenn Sie den Debugger beenden und zum Code-Editor zurückkehren möchten, können Sie anstelle von Neu starten die rote Schaltfläche auswählen.

Untersuchen von Variablen mithilfe von Datentipps

Da Sie sich nun ein wenig auskennen, können Sie damit beginnen, den Zustand Ihrer App (Variablen) mit dem Debugger zu überprüfen. Die Features, mit denen Sie Variablen untersuchen können, zählen zu den nützlichsten Einsatzgebieten des Debuggers. Es gibt verschiedene Möglichkeiten, Variablen zu untersuchen. Beim Debuggen eines Problems müssen Sie häufig herausfinden, ob Variablen die Werte speichern, die diese bei einem bestimmten App-Zustand aufweisen sollten. Ausführliche Informationen zur Verwendung von Datentipps finden Sie unter Anzeigen von Datenwerten in Datentipps.

Zeigen Sie mit der Maus auf ein Objekt, während der Debugger pausiert ist, um den Standardeigenschaftswert anzuzeigen.

Wenn die Variable über Eigenschaften verfügt, können Sie das Objekt erweitern, um alle zugehörigen Eigenschaften anzuzeigen.

Beim Debuggen möchten Sie die Eigenschaftswerte für Objekte häufig schnell überprüfen. Die Datentipps stellen eine gute Methode hierfür dar.

Untersuchen von Variablen über die Fenster „Auto“ und „Lokal“

Im Fenster Auto werden Ihnen Variablen, deren Typ und der aktuelle Wert angezeigt. Im Fenster Auto werden sämtliche Variablen angezeigt, die in der aktuellen Zeile oder der vorangehenden Zeile verwendet werden (in C++ werden in den vorangehenden drei Codezeilen Variablen angezeigt. In der Dokumentation finden Sie Informationen zum sprachspezifischen Verhalten). Weitere Informationen zur Verwendung dieser Fenster finden Sie unter Untersuchen von Variablen über die Fenster „Auto“ und „Lokale Variablen“.

Sehen Sie sich das Fenster Auto während des Debuggens unten im Code-Editor an.

Sehen Sie sich als Nächstes das Fenster Lokal an. Im Fenster Lokal werden Ihnen die Variablen angezeigt, die sich derzeit im Gültigkeitsbereich befinden.

In diesem Beispiel befinden sich die Objekte this und f im Gültigkeitsbereich. Weitere Informationen finden Sie unter Inspect Variables in the Autos and Locals Windows (Überprüfen von Variablen in den Fenstern „Auto“ und „Lokal“).

Festlegen von Überwachung

Sie können über das Fenster Überwachung eine Variable (oder einen Ausdruck) angeben, die Sie im Auge behalten möchten. Weitere Informationen finden Sie unter Festlegen einer Überwachung mithilfe der Fenster „Überwachung“ und „Schnellüberwachung“.

Klicken Sie während des Debuggens mit der rechten Maustaste auf ein Objekt, und wählen Sie Überwachung hinzufügen aus.

In diesem Beispiel wurde festgelegt, dass das Objekt überwacht werden soll, und Sie können seine Wertänderung sehen, wenn Sie durch den Debugger navigieren. Im Gegensatz zu den anderen Variablenfenstern werden im Fenster Überwachung immer die Variablen angezeigt, die von Ihnen überwacht werden (wenn sie außerhalb des gültigen Bereichs liegen, sind sie ausgegraut).

Überprüfen der Aufrufliste

Im Fenster Aufrufliste wird die Reihenfolge angezeigt, in der Methoden und Funktionen aufgerufen werden. In der obersten Zeile wird die aktuelle Funktion angezeigt. In der zweiten Zeile wird die Funktion oder Eigenschaft angezeigt, über die sie aufgerufen wurde, usw. Die Aufrufliste bietet eine nützliche Möglichkeit zum Untersuchen und Verstehen des Ausführungsablaufs einer App. Weitere Informationen hierzu finden Sie unter Vorgehensweise: Untersuchen der Aufrufliste.

Klicken Sie während des Debuggens auf das Fenster Aufrufliste. Dieses Fenster ist standardmäßig im unteren rechten Bereich geöffnet.

Sie können auf eine Codezeile doppelklicken, um den Quellcode anzuzeigen. Dadurch wird auch der aktuelle Bereich geändert, der vom Debugger untersucht wird. Dadurch wird der Debugger nicht weiter ausgeführt.

Sie können auch über die Kontextmenüs im Fenster Aufrufliste weitere Aktionen ausführen. So können Sie beispielsweise Breakpoints in bestimmte Funktionen einfügen, Ihre App mithilfe von Ausführen bis Cursor neu starten und Quellcode untersuchen.

Untersuchen einer Ausnahme

Wenn Ihre App eine Ausnahme auslöst, springt der Debugger in die Codezeile, die diese verursacht hat. Ausführliche Informationen finden Sie unter Untersuchen einer Ausnahme mithilfe des Ausnahmenhilfsprogramms.

Die Ausnahmen-Hilfe ist beim Debuggen von Fehlern sehr nützlich. Sie können zusätzlich Fehlerdetails anzeigen und eine Überwachung über die Ausnahmen-Hilfe hinzufügen. Bei Bedarf können Sie die Bedingungen ändern, die zum Auslösen einer bestimmten Ausnahme führen. Weitere Informationen zum Behandeln von Ausnahmen in Ihrem Code finden Sie unter Debugging techniques and tools (Debugverfahren und Tools).

Erweitern Sie den Knoten Ausnahmeeinstellungen, um weitere Optionen zu diesem Ausnahmetyp anzuzeigen. Für dieses Tutorial müssen Sie dort jedoch keine Änderungen vornehmen.

Konfigurieren des Debuggens

Sie können Ihr Projekt so konfigurieren, dass es als Debug- oder Releasekonfiguration erstellt wird, Projekteigenschaften für das Debuggen oder allgemeine Einstellungen für das Debuggen konfigurieren. Außerdem können Sie den Debugger so konfigurieren, dass benutzerdefinierte Informationen mithilfe von Features wie dem DebuggerDisplay-Attribut oder, für C/C++, dem NatVis-Framework angezeigt werden.

Debuggingeigenschaften sind für jeden Projekttyp spezifisch. Beispielsweise können Sie ein Argument angeben, das beim Start an die Anwendung übergeben werden soll. Auf diese Konfigurationseinstellungen können Sie zugreifen, indem Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt klicken und Eigenschaften auswählen. Debuggingeigenschaften werden in der Regel abhängig vom jeweiligen Projekttyp auf der Registerkarte Erstellen oder Debuggen angezeigt.

Debuggen von ASP.NET-Live-Apps in Azure App Service

Informationen zum Debuggen in Azure App Service finden Sie unter Debuggen von Azure-Apps.

Der Momentaufnahmedebugger erstellt (nur) in Visual Studio Enterprise eine Momentaufnahme von Ihren in der Produktion befindlichen Apps, wenn Code ausgeführt wird, der für Sie von Interesse ist. Legen Sie Andockpunkte und Protokollpunkte in Ihrem Code fest, um den Debugger anzuweisen, eine Momentaufnahme zu erstellen. Der Debugger zeigt Fehler ohne Auswirkungen auf den Datenverkehr Ihrer Produktionsanwendung an. Der Momentaufnahmedebugger kann Sie dabei unterstützen, die Zeit zum Beheben von Fehlern, die in Produktionsumgebungen auftreten, erheblich zu reduzieren.

Die Momentaufnahmensammlung ist für ASP.NET-Apps verfügbar, die in Azure App Service ausgeführt werden. ASP.NET-Apps müssen mit .NET Framework 4.6.1 oder höher ausgeführt werden, und ASP.NET Core-Apps müssen unter Windows mit .NET Core 2.0 oder höher ausgeführt werden.

Weitere Informationen finden Sie unter Debug live ASP.NET apps using the Snapshot Debugger (Debuggen von ASP.NET-Live-Apps mithilfe des Momentaufnahmedebuggers).

Anzeigen von Momentaufnahmen mit dem IntelliTrace-Feature „Schritt zurück“ (Visual Studio Enterprise)

Das IntelliTrace-Feature „Schritt zurück“ erstellt bei jedem Breakpoint und Debuggerschritt automatisch eine Momentaufnahme Ihrer Anwendung. Durch die erfassten Momentaufnahmen können Sie zu vorherigen Haltepunkten oder Schritten zurückkehren und sich den Zustand der Anwendung so anzeigen lassen, wie er zuvor war. Mit dem IntelliTrace-Feature „Step-back“ können Sie Zeit sparen, wenn Sie den vorherigen Zustand der Anwendung anzeigen oder diesen wiederherstellen, aber das Debuggen nicht erneut starten möchten.

Sie können Momentaufnahmen anzeigen und durch diese navigieren, indem Sie die Schaltflächen Schritt zurück und Schritt vor in der Debugsymbolleiste verwenden. Mit diesen Schaltflächen können Sie durch die Ereignisse navigieren, die in der Registerkarte Ereignisse des Fensters Diagnosetools angezeigt werden.

Weitere Informationen finden Sie auf der Seite Inspect previous app states using IntelliTrace (Untersuchen vorheriger App-Zustände mithilfe von IntelliTrace).

Debuggen von Leistungsproblemen

Wenn Ihre App langsam ausgeführt wird oder zu viel Arbeitsspeicher nutzt, müssen Sie Ihre App möglicherweise frühzeitig mit den Profilerstellungstools testen. Weitere Informationen über Profilerstellungstools wie das CPU-Auslastungstool und des Arbeitsspeicheranalyzer finden Sie in der Einführung in Profilerstellungstools.

Zugehöriger Inhalt

In diesem Tutorial haben Sie einen ersten Einblick in die zahlreichen Features des Debuggers erhalten. Vielleicht sollten Sie sich eines dieser Features genauer ansehen, z. B. Breakpoints.