7.3 Fehlersuche mit Visual Studio 2012

Unter dem Begriff Debugging ist die Suche nach Fehlern in einem Programm zu verstehen. Sie müssen ein Programm debuggen, wenn es nicht so funktioniert, wie Sie es sich vorgestellt haben, oder wenn es falsche Ergebnisse liefert. Die Ursache für das Fehlverhalten kann das Debuggen liefern. Visual Studio 2011 unterstützt das Debuggen sowohl von lokalen als auch von entfernten (Remote-) .NET-Anwendungen. Da wir uns in diesem Buch nur mit lokalen Anwendungen beschäftigen, schenken wir dem Remote Debugging keine Beachtung.

Der Debugger kann nur zur Laufzeit eines Programms benutzt werden. Darüber hinaus muss das Programm auch noch angehalten sein. Hier gibt es drei verschiedene Möglichkeiten:

• Die Laufzeit der Anwendung erreicht einen Haltepunkt.
• Die Anwendung führt die Methode Break der Klasse Debugger aus.
• Es tritt eine Ausnahme auf.

7.3.1 Debuggen im Haltemodus

Auf der linken Seite im Codeeditor ist ein grauer, vertikaler Balken zu sehen. Dieser dient nicht dazu, die Optik des Codefensters zu verbessern, sondern in bestimmten Codezeilen Haltepunkte zu setzen. Dazu klicken Sie mit der Maus auf den grauen Balken. Alternativ können Sie auch den Cursor in die Zeile setzen, der ein Haltepunkt hinzugefügt werden soll, und dann die Taste drücken. Haltepunkte können jeder Codezeile hinzugefügt werden, die eine Programmanweisung enthält. Ein roter Punkt symbolisiert den Haltepunkt, der beim Anklicken und durch die -Taste wieder entfernt wird.

Trifft die Laufzeitumgebung auf einen Haltepunkt, hält der Debugger an dieser Stelle die Programmausführung an. Die mit dem Haltepunkt gekennzeichnete Codezeile ist in diesem Moment noch nicht ausgeführt. Im Haltemodus können Sie einzelne Variableninhalte untersuchen, ändern oder den Programmcode in gewünschter Weise fortsetzen. Dabei werden Sie auch von mehreren Fenstern des Debuggers unterstützt: Überwachen, Lokal und Auto.

Um ein unterbrochenes Programm fortzusetzen, haben Sie mehrere Möglichkeiten: über das Menü Debuggen, die gleichnamige Symbolleiste (diese wird standardmäßig nicht angezeigt und muss gegebenenfalls der Entwicklungsumgebung hinzugefügt werden) und diverse Tastenkürzel.

Befindet sich die Laufzeit einer Anwendung im Haltemodus, können Sie die weitere Programmausführung wie folgt beeinflussen:

• Einzelschritt – Der Programmcode wird Zeile für Zeile ausgeführt. Das Tastaturkürzel dafür ist . Mit wird auch in einer aufgerufenen benutzerdefinierten Methode jede Codezeile einzeln ausgeführt.
• Prozedurschritt – Der Programmcode wird weiterhin in Einzelschritten ausgeführt. Stößt er jedoch auf den Aufruf einer benutzerdefinierten Methode, wird diese sofort vollständig ausgeführt. Das Tastaturkürzel ist .
• Ausführen bis Rücksprung – Die aktuelle Methode wird bis zu ihrem Ende sofort ausgeführt. Danach wird der Haltemodus wieder aktiviert. Die Tastenkombination ist + .

Bei den Haltepunkten müssen Sie eine Besonderheit von Visual Studio im Zusammenhang mit den Eigenschaften beachten. Per Vorgabe werden die Eigenschaftsmethoden wie Variablen behandelt, was zur Konsequenz hat, dass beim Bearbeiten einer Eigenschaft nicht in die Eigenschaftsmethode gesprungen wird. Dieses Standardverhalten können Sie im Optionen-Dialog abändern, indem Sie den Dialog unter Extras • Optionen öffnen und dort unter Debugging • Allgemein die entsprechende Einstellung ändern (siehe Abbildung 7.10).

Abbildung 7.10 Option zum Überspringen von Eigenschaftsmethoden

Variableninhalte in einem »QuickInfo«-Fenster

Um sich den aktuellen Zustand einer Variablen anzeigen zu lassen, fährt man im Haltemodus mit dem Mauszeiger auf den Variablenbezeichner. Der Inhalt einschließlich einer kleinen Beschreibung wird daraufhin in einem QuickInfo-Fenster angezeigt. Im QuickInfo-Fenster können Sie sogar den Inhalt der Variablen verändern.

Bedingte Haltepunkte

Die im vorhergehenden Abschnitt beschriebenen Haltepunkte unterbrechen in jedem Fall die Programmausführung, weil sie an keine Bedingungen gebunden sind. Der Debugger ermöglicht auch die Festlegung von Haltepunkten, die eine Anwendung nur dann in den Haltemodus setzen, wenn bei Erreichen des Haltepunkts bestimmte Bedingungen erfüllt sind. Um eine Bedingung festzulegen, gehen Sie mit dem Cursor in die Codezeile des betreffenden Haltepunkts, öffnen das Kontextmenü und wählen Haltepunkt • Bedingung.... Das Fenster, das sich daraufhin öffnet, sehen Sie in Abbildung 7.11.

Abbildung 7.11 Festlegen einer Haltepunktbedingung

Legen Sie nun die Bedingung fest, unter der der Haltepunkt zur Laufzeit berücksichtigt werden soll. In der Abbildung wäre das genau dann der Fall, wenn die Variable value einen Wert kleiner 8 aufweist. Ist value gleich oder größer 8, wird das laufende Programm in dieser Codezeile nicht unterbrochen. Alternativ kann auch das Optionsfeld Hat sich geändert markiert werden. Der Debugger prüft dann zuerst, ob sich der Wert der Variablen seit dem letzten Erreichen des Haltepunktes geändert hat. Wenn dies der Fall ist, ist die Bedingung erfüllt, und das Programm wird unterbrochen.

Haltepunkt mit Trefferanzahl aktivieren

Im Kontextmenü eines Haltepunktes können Sie sich auch für die Option Trefferanzahl... entscheiden. Wenn für einen Haltepunkt keine Trefferanzahl angegeben wurde, wird das Programm immer unterbrochen, wenn der Haltepunkt erreicht wird oder die definierte Bedingung erfüllt ist. Die Festlegung der Trefferanzahl bietet sich z. B. an, wenn die Anzahl der Schleifendurchläufe festgelegt werden soll, bis der Haltepunkt aktiv wird. Ist eine Vorgabe getroffen, wird die Ausführung nur bei Erreichen der Trefferanzahl unterbrochen. Aus einem Kombinationslistenfeld können Sie eine der vier angebotenen Einstellungen wählen.

Abbildung 7.12 Festlegen der Trefferanzahl

Verwalten der Haltepunkte

Die Eigenschaften aller Haltepunkte kann man sich im Haltepunktfenster anzeigen lassen. Wählen Sie dazu das Menü Debuggen • Fenster • Haltepunkte. Dieses Fenster ist als Verwaltungstool sehr nützlich, um sich einen Überblick über alle gesetzten Haltepunkte zu verschaffen, die Bedingungen jedes einzelnen zu überprüfen und gegebenenfalls auch zu verändern. Können oder wollen Sie zum Testen einer Anwendung auf einen oder mehrere Haltepunkte verzichten, entfernen Sie einfach das Häkchen vor dem entsprechenden Haltepunkt. Im Codeeditor ist die zu diesem Haltepunkt gehörende Kreisfläche danach nicht mehr farblich ausgefüllt, sondern nur noch als Kreis erkennbar. Die deaktivierten Haltepunkte lassen sich später wieder aktivieren, ohne dass die eingestellten spezifischen Eigenschaften verloren gehen.

Abbildung 7.13 Die Liste aller Haltepunkte

7.3.2 Das »Direktfenster«

Das Direktfenster wird für Debug-Zwecke, das Auswerten von Ausdrücken, das Ausführen von Anweisungen, das Drucken von Variablenwerten usw. verwendet. Es ermöglicht die Eingabe von Ausdrücken, die von der Entwicklungssprache während des Debuggens ausgewertet oder ausgeführt werden sollen. Um das Direktfenster anzuzeigen, wählen Sie im Menü Debuggen • Fenster und dann Direkt.

Welche Möglichkeiten sich hinter dem Direktfenster verbergen, sollten wir uns an einem Beispiel verdeutlichen. Zu Demonstrationszwecken bedienen wir uns des folgenden Programmcodes:

class Program {
  static void Main(string[] args) {
    int x = 10;
    int y = 23;
    int z = x + y;
    Console.Write(z);
  }
  static void DebugTestProc() {
    Console.WriteLine("In DebugTestProc");
  }
}

Listing 7.19 Code zum Testen des Direktfensters

Operationen im Direktfenster setzen den Haltemodus voraus. Daher legen wir einen Haltepunkt in der Codezeile

int z = x + y;

fest. Nach dem Starten des Projekts stoppt das Programm die Ausführung am Haltepunkt. Sollte das Direktfenster in der Entwicklungsumgebung nicht angezeigt werden, müssen Sie es noch öffnen. Sie können nun im Direktfenster

?x

eingeben, um sich den Inhalt der Variablen x anzeigen zu lassen. Das Fragezeichen ist dabei notwendig. Ausgegeben wird im Befehlsfenster der Inhalt 10.

Wenn Sie Lust haben, können Sie auch den Inhalt aus dem Direktfenster heraus ändern. Dazu geben Sie

x = 250

ein. Wenn Sie danach den Code ausführen lassen, wird an der Konsole der Inhalt von z zu 273 berechnet und nicht, wie ursprünglich zu vermuten gewesen wäre, zu 33. Die Änderung einer Variablen im Direktfenster wird also von der Laufzeit berücksichtigt.

Sogar die Methode DebugTestProc können wir aus dem Direktfenster heraus aufrufen. Dazu geben wir nur

DebugTestProc()

ein.

7.3.3 Weitere Alternativen, um Variableninhalte zu prüfen

Logische Fehler basieren darauf, dass Variablen unerwartete Inhalte aufweisen, der Programmcode aber syntaktisch richtig ist. Das Direktfenster ist eine Möglichkeit, Variablen zu prüfen, die jedoch nicht sehr komfortabel ist, wenn der Programmcode eines größeren Projekts untersucht werden muss. Visual Studio stellt aber mehrere weitere Alternativen zur Verfügung, die noch bessere und detailliertere Informationen bereitstellen. Allen Alternativen ist gemeinsam, dass sie nur im Haltemodus geöffnet werden können. Sie können dazu das Menü Debuggen • Fenster benutzen, teilweise auch das Kontextmenü des Codeeditors. Die Variableninhalte lassen sich, wie auch im Befehlsfenster, verändern, um beispielsweise das Laufzeitverhalten der Anwendung in Grenzsituationen zu testen.

Das »Auto«-Fenster

Das Auto-Fenster zeigt alle Variablen der Codezeile an, in der sich der Haltemodus aktuell befindet, sowie alle Variablen der vorausgehenden Codezeile. Angezeigt werden neben dem Namen der Inhalt und der Datentyp. Wird beispielsweise in der Zeile 5 des folgenden Programmcodes ein Haltepunkt gesetzt, werden im Auto-Fenster die aktuellen Inhalte der Variablen x, y und z angezeigt (siehe Abbildung 7.14).

1:  static void Main(string[] args) {
2:     double a = 22.5;
3:     int x = 10;
4:     int y = 23;
5:     int z = x + y;
6:     Console.Write(z);
7: }

Listing 7.20 Programmcode zum Testen des »Auto«-Fensters

Abbildung 7.14 Das »Auto«-Fenster

Das »Lokal«-Fenster

Das Fenster Lokal enthält alle Variablen mit Namen, Wert und Typ, die in der aktuellen Methode definiert sind. Variablen, die sich zwar im Gültigkeitsbereich einer Methode befinden, aber außerhalb deklariert sind, werden nicht vom Lokal-Fenster erfasst.

Das »Überwachen«-Fenster

Sie können ein Überwachungsfenster öffnen und die Variablen angeben, die vom Debugger überwacht werden sollen. Um eine Variable einem Überwachungsfenster zuzuordnen, markieren Sie die entsprechende Variable zur Laufzeit im Haltemodus und wählen im Kontextmenü Überwachung hinzufügen. Wollen Sie weitere Variablen überwachen lassen, können Sie diese auch manuell eintragen oder ebenfalls über das Kontextmenü der Variablen hinzufügen.

Abbildung 7.15 Das Fenster »Überwachen«

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.