Debugging in Visual Studio

Wenn eine Anwendung sich nicht so verhält wie gewünscht oder diese sogar Ausnahmen auslöst, wollen wir herausfinden, warum das so ist. Wurde ein Wert nicht oder falsch gesetzt, konnte ein Objekt nicht gefüllt werden oder was ist die Ursache für das Problem Hier kommen die Debugging-Techniken von Visual Studio ins Spiel. Der vorliegende Artikel stellt die gängigsten Techniken zum Debuggen von Code unter Visual Studio vor.

Das Wort Debuggen kommt der Sage nach vom Wort Bug. Früher wurden zum Durchführen von Rechenoperationen in Computern Relais verwendet, die durch Insekten blockiert werden konnten. Das Entfernen dieser Tierchen wurde schließlich Debuggen genannt – ein Begriff, der sich bis heute gehalten hat. Nur, dass Bug heute nicht mehr sprichwörtlich Käfer bedeutet, sondern schlicht Programmierfehler.

Anwendung zum Debuggen starten

Grundsätzlich gibt es zwei Modi zum Ausführen von .NET-Anwendungen: Den Debug-Modus und den Release-Modus. Der Release-Modus erzeugt eine leistungsoptimierte Version der Anwendung – diese entspricht auch der Version der Anwendung, die Sie mit dem Erstellen eines Projekts erhalten. Der Debug-Modus hingegen erlaubt es, bei Fehlern den Quellcode anzuzeigen, der für den Fehler verantwortlich ist. Außerdem können Sie in diesem Modus Informationen über den Zustand von Objekten und Variablen erhalten, die gerade im Gültigkeitsbereich liegen und Meldungen ausgeben sowie weitere Funktionen nutzen, die wir Ihnen im Laufe dieses Artikels vorstellen werden. Standardmäßig ist für das Starten einer Anwendung von Visual Studio aus der Debug-Modus eingestellt. Diese Einstellung können Sie leicht über das Menü von Visual Studio ändern (siehe Bild 1).

Bild 1: Einstellen des Ausführungsmodus, hier Debug

Um die Anwendung nun im Debugging-Modus zu starten, betätigen Sie entweder die Taste F5, klicken auf die Schaltfläche mit dem grünen Pfeil und dem Text Starten oder wählen den Menü-Eintrag Debuggen|Debuggen starten.

Zum Debuggen anhalten

Um eine Anwendung zu debuggen, muss der laufende Code angehalten werden. Dazu gibt es verschiedene Möglichkeiten:

• Es tritt eine Ausnahme auf, also ein Fehler im Code, der eine weitere Ausführung des Codes verhindert. Ein Beispiel sehen Sie in Bild 2.



Bild 2: Debuggen wird durch Laufzeitfehler ermöglicht

• Sie legen einen Haltepunkt im Code fest, damit der Code auch ohne einen Laufzeitfehler an der gewünschten Stelle angehalten und untersucht werden kann.
• Sie fügen der Anwendung an der gewünschten Stelle die Methode Break der Klasse Debugger hinzu. Dies entspricht der Stop-Anweisung, die Sie vielleicht von Access/VBA kennen. Der Code wird genau an dieser Stelle angehalten.

Haltepunkt setzen

Einen Haltepunkt im Code setzen Sie, indem Sie im Codefenster in der Zeile, in der die Ausführung angehalten werden soll, in den linken, grauen Bereich klicken, sodass dort ein roter Punkt erscheint (siehe Bild 3).

Bild 3: Haltepunkt

Eine alternative Möglichkeit zum Hinzufügen von Haltepunkten ist die Taste F9. Bewegen Sie die Einfügemarke in die gewünschte Zeile und betätigen Sie diese Taste, um einen Haltepunkt hinzuzufügen oder diesen wieder zu entfernen.

Sie können alle ausführbaren Zeilen mit einem Haltepunkt versehen, was alle Zeilen mit Ausnahme der Deklarationszeilen umfasst.

Wenn die Ausführung an der markierten Zeile stoppt, bedeutet das übrigens, dass die markierte Zeile noch nicht ausgeführt wurde. Wenn Sie also Variablen in einer Zeile nach der Ausführung (etwa der Zuweisung eines Wertes an eine Variable) untersuchen möchten, können Sie den Haltepunkt auch gleich auf die folgende Zeile verschieben.

Haltepunkte per Code

Eine weitere Möglichkeit, einen Haltepunkt zu setzen, bietet die Klasse Debugger. Diese stellt die Methode Break zur Verfügung, die beim Erreichen den Code unterbricht (siehe Bild 4).

Bild 4: Programmierter Stop

Warum sollte man diese Methode nutzen, statt einfach einen Haltepunkt zu setzen Unter Access und dem VBA-Editor wurden Haltepunkte gelöscht, wenn man die Anwendung geschlossen und erneut geöffnet hat. Das war unter Access der Grund, die Stop-Anweisung zu verwenden – wenn die Anwendung abgestürzt ist, war diese nach dem Neustart wieder vorhanden, die Haltepunkte aber nicht. Unter Visual Studio sind die Haltepunkte allerdings nach dem Schließen und erneuten Öffnen des Projekts noch vorhanden – eigentlich braucht man Debugger.Break also nicht.

Beim Erreichen eines Haltepunktes

Wenn Sie beim Debuggen einen Haltepunkt erreichen, können Sie verschiedene Aktionen durchführen. Die erste ist, Informationen über die aktuelle Situation zu ermitteln. Dazu können Sie beispielsweise über den Namen einer Variablen fahren, um ihren aktuellen Wert zu ermitteln (siehe Bild 5).

Bild 5: Auslesen von Variableninhalten

Weiter im Code

Wenn Sie einen Haltepunkt erreicht haben und das Debuggen nun fortsetzen wollen, gibt es dazu folgende Möglichkeiten:

• Sie betätigen erneut die Taste F5 und der Code läuft weiter bis zum Schluss oder bis er durch einen weiteren Haltepunkt oder einen Fehler angehalten wird.
• Sie betätigen die Taste F11, um jeweils eine Zeile auszuführen.

Letztere Möglichkeit ist interessant, wenn Sie im Detail die einzelnen Zeilen des Codes durchlaufen wollen.

Laufzeitfehler untersuchen

Wenn Sie beim Debuggen auf einen Laufzeitfehler stoßen, der nicht behandelt wird, können Sie damit einige Informationen erhalten, die für eine Behandlung des Fehlers im Code nützlich sind.

Wie die Fehlermeldung einer unbehandelten Ausnahme aussieht, haben wir bereits weiter oben betrachtet. Hier finden wir noch einige weiterführende Möglichkeiten. Die wichtigste ist der Link Details anzeigen, mit dem Sie ein Fenster wie in Bild 6 öffnen können.

Bild 6: Fehlerdetails beim Auftreten einer Ausnahme

Hier finden Sie detaillierte Informationen zu der Ausnahme. In vielen Fällen können Sie unter InnerException noch weitere Informationen anzeigen, wie es in der Abbildung der Fall ist.

Code während des Debugging bearbeiten

Eine wichtige Funktion ist das Bearbeiten des Codes während des Debuggings. Damit dies funktioniert, aktivieren Sie die Optionen aus Bild 8 im Bereich Debugging des Optionen-Dialogs, den Sie mit dem Menübefehl Extras|Optionen öffnen – und die normalerweise bereits aktiviert sind..

Bild 7: Aktivieren des Bearbeitens von Code während des Debuggens

Es werden allerdings nicht alle Änderungen unterstützt. Unter folgendem Link finden Sie eine Liste der unterstützten und nicht unterstützten Änderungen:

https://github.com/dotnet/roslyn/blob/master/docs/wiki/EnC-Supported-Edits.md

Debugging steuern

Neben dem Starten und Fortsetzen des Debuggings mit F5 und dem Durchführen von Einzelschritten mit F11 gibt es noch weitere Optionen, die Sie auch im Menüpunkt Debuggen finden (siehe Bild 7). Wenn Sie einmal die Tastenkombination für einen der Befehle suchen, können Sie diese auch in diesem Menü einsehen. Die Befehle im Einzelnen:

Bild 8: Kontextmenü-Befehle zum Debuggen

• Weiter (F5): Setzt den Code bis zum nächsten Haltepunkt oder Fehler beziehungsweise bis zum Ende des Codes durch.
• Alle unterbrechen (Strg + Alt + Pause): Unterbricht an der aktuell ausgeführten Codezeile.
• Debuggen beenden (Umschalt + F5): Beendet das Debuggen.
• Neu starten (Strg + Umschalt + F5): Beendet das Debugging und startet es erneut.
• Prozedurschritt (F10): Führt die Anweisungen der aktuellen Methode im Einzelschrittmodus aus, aber springt nicht in andere, von dieser Methode aus aufgerufene Methoden.
• Ausführen bis Rücksprung (Umschalt + F11): Springt von der aktuellen Methode direkt zur aufrufenden Methode, wenn überhaupt ein Aufruf von einer anderen Methode erfolgt ist.

Damit erhalten wir recht exakt die gleichen Funktionen und Tastenkombinationen wie im VBA-Editor von Access – mit dem Unterschied, dass statt der Taste F8 die Taste F11 zum Einsatz kommt.

Es gibt noch weitere Befehle, die allerdings erst bei laufendem Debugging durch einen Mausklick mit der rechten Maustaste in das Codefenster auftauchen (siehe Bild 9). Interessant sind hier die folgenden Befehle:

Username or Email

Passwort

Angemeldet bleiben