Unsere Datenschutzrichtlinie wird in Kürze aktualisiert. Bitte sehen Sie sich die Vorschau an.

Visual Studio 2013 Grundkurs

Debugging

Testen Sie unsere 2017 Kurse

10 Tage kostenlos!

Jetzt testen Alle Abonnements anzeigen
Visual Studio 2013 verfügt über einen leistungsstarken und einfach zu bedienenden Debugger. Dieser analysiert den Quellcode und findet etwaig auftretende Fehler.
08:38

Transkript

Jeder Entwickler träumt davon, dass er Anwendungen schreibt die fehlerfrei sind. Manchmal werden Träume wahr. In der Hinsicht definitiv nicht, denn Sie werden niemals in Ihrem Leben ein Programm schreiben was ein bisschen komplexer ist und was definitiv fehlerfrei sein wird. Das ist auch alles gar nicht so schlimm, denn Visual Studio bietet mit dem Debugger eine exzellente Möglichkeit Fehler aufzufinden, Code zu analysieren und diesem Fehler dann später zu fixen. Wenn wir den Debugger starten möchten, gehen wir einfach hier normal, ganz oben über den Punkt "Starten" oder den Menüpunkt Debuggen Debuggen starten. Ich gehe jetzt einfach mal hin und starte den Debugger und wir werden feststellen, dass er jetzt zwar an einer Stelle aussteigt und eine Exception auslöst, aber zumindestens ist er gestartet und ist an einer Stelle hängengeblieben. Und diese Stelle möchten wir jetzt gleich mal schrittweise analysieren, das heißt, wir möchten jetzt nicht, dass die Anwendung quasi startet und bis zu dem Punkt kommt an dem es knallt, sondern wir möchten, dass die Anwendung "var" stehenbleibt, zum Beispiel in dieser Zeile und das Debuggen heißt, ich halte das Programm an einer gewissen Programmstelle an und steppe dann schrittweise durch meinen Programmcode durch. Ich sage also er soll in dieser Zeile anhalten und setzte ein sogenannten "Break Point" hier durch einen Klick in die linke graue Leiste und dann erscheint hier so ein kleiner roter Punkt und die Zeile ist jeweils rot markiert. Wenn ich jetzt diese Anwendung nochmal ausführe, wird sie gestartet und bei erreichen dieses Break Points wird hier die Anwendung angehalten, das ist zu erkennen an diesem kleinen gelben Pfeil. So ich kann jetzt hier mit entsprechenden Commands durch mein Code durchnavigieren. Dazu habe ich drei verschiedene Varianten: Einmal den "Einzelschritt", den "Prozedurschritt" und "Ausführen bis Rücksprung". Die schauen wir uns jetzt alle drei mal an. Ich werde jetzt aber nicht jedes mal dieses Menü hier reinspringen, sondern ich werde die Shortcuts verwenden. Einzelschritt ist F11, Prozedurschritt F10 und Ausführen bis Rücksprung ist Umschalt+F11. So ich gehe jetzt also durch diesen Code durch, ich drücke jetzt F11 und diese markierte Zahl an dieser Stelle heißt immer, dass als nächstes diese Zeile ausgedrückt wird, wenn ich den nächsten Einzelschritt mache. Ich mache diesen Einzelschritt also, diese Zeile wurde ausgeführt. Jetzt ist er kurz davor diese Zeile auszuführen, also ein entsprechendes Objekt zu instanziieren. Ich drücke einmal F11 und dann wird diese Zeile ausgeführt. Ich kann jetzt hingehen und kann hier sagen, da wurde ein Objekt erstellt, ich möchte dieses Objekt untersuchen, ich möchte analysieren wo der Fehler herkommt, also gehe ich einfach mit der Maus über mein Objekt und bekomme hier dieses Objekt angezeigt und sehe zum Beispiel, okay, das Objekt hat ein Property Age und das ist initialisiert mit dem Wert 0. Normalerweise wenn in dieser Klasse ein Standardkonstruktor implementiert worden wäre, wäre ich jetzt an der Stelle auch in die entsprechenden Standardkonstruktor Implementierung gesprungen und hätte dort weiter debuggen können und am Ende dieses Konstruktors wäre ich wieder hierhin zurückgesprungen. Klingt jetzt ein bisschen verwirrend, wir machen es bei der nächsten Zeile, denn hier haben wir einen Methodenaufruf mit "DoBar (5, 5.6)" und ich drücke jetzt F11 und mit drücken F11 springen wir in diese Methode DoBar rein. Auch hier kann ich wie wir es gerade gesehen haben diese Variablen hier oben untersuchen und kann mir den Wert 5 anzeigen lassen und 5.6,das haben wir von außen übergeben. So, jetzt kann es ja sein, dass ich diese Fehler identifiziert habe und gemerkt habe, okay, hier müsste der Wert nicht 5.6 sein sondern 4.6 und ich möchte das mal kurz testen. Da kann ich hingehen und kann diesen Wert im Debugger verändern und nicht nur im Debugger, sondern auch im gesamten Programm. Das heißt, wenn ich jetzt hier mit dem Mauscursor wieder drübergehe, ich hätte Enter drücken müssen, so, das heißt, wenn ich jetzt hier mit dem Mauscursor drübergehe, sieht man, ich habe den Wert von 5.6 auf 4.6 geändert. Und dann kann ich jetzt mit F11 weiter hier durchsteppen und dann lande ich irgendwann bei einer Exception. Das ist jetzt hier eine von Hand ausgelöste, das könnte auch irgendeine andere sein, also der Fehler sein an dem wir uns gerade befinden und dann bekommen wir eine sogenannte "NotImplementedException". Ein NotImplementedException erreicht man oft, wenn man dann einen Fehler sucht oder generell eine Exception, nicht unbedingt ein NotImplementedException und dann bekomme ich hier so eine Fehler-Detailsansicht angezeigt und unter "Deatils anzeigen" bekomme ich dann die Möglichkeit dieses Exception Objekt, was dort erstellt wurde zu analysieren. Ich kann also jetzt hier gucken, was es genau die Fehlermeldung: "Die Methode oder der Vorgang ist nicht implementiert", ich kann mir Daten dazu anschauen, irgendwie ein HResult, ich kann gucken, ob es noch irgendwie eine andere Exception gab, die Auslösung für diese Exception war, ich kann aber auch hingehen und mir hier den sogenannten StrachTrace anschauen und ich kann mir hier angucken welche Methoden wurden den überhaupt aufgerufen, ich sehe Ok [unverständlich] gestartet, dann ist er hier durchgegangen, durchgegangen,durchgegangen hier war ein Main Funktion und als nächstes hat er dann die Methode DoBar aufgerufen, ich kann also sehen, in welche Reihenfolge welche Methoden aufgerufen wurden und in welcher aktuellen Methode er ist. Das heißt, hier wurde innerhalb meiner Program CS 14, wurde die Main Methode aufgerufen, aus der Main Methode wurde meine DoBar ausgerufen und immer die Methode die oben auf dem Stack liegt hat die entsprechende Exception ausgelöst. So wie gesagt, so ein kleiner Ausflug in dieses Exception-Window. Wir haben also jetzt hier an der Stelle eine Exception gefunden und wir beheben den Code gerade einfach mal und sagen hier, okay, wir machen einfach nur ein "return z1+(int)z2" und damit haben wir diesen Code gefixt. So jetzt könnte ich gucken, ist jetzt er Fehler behoben an der Stelle, ich starte also diese Anwendung nochmal und steppe jetzt wieder mit F11 hier rein und gucke mir das jetzt hier an, kann wieder die Werte anschauen, ich lasse jetzt mal 5.6 und dann springen wir an dieser Stelle wieder aus unserer Methode raus. Zusätzlich zu der Möglichkeit die Variablen hier anhand von meinem Mouseover zu untersuchen zum Beispiel hier das Class oder jetzt das Result, wenn ich die Zeile ausführe, 10 habe ich noch hier unten das sogenannte Auto-Window. Das Auto-Window zeigt mir immer alle Variablen an, die aktuell in diesem Ausführungsblock gültig sind. In diesem Fall ist natürlich einmal "class1", das sieht man hier und wir sehen hier an der Stelle "result". Das Result ist quasi das, was an dieser Stelle von unserer Methode zurückgegeben wurde. Jetzt haben wir gerade einen Schritt zu weit gemacht, das heißt,das hier sind die aktuell sichtbaren Variablen, ich Starte nochmal unsere Anwendung, den Debugger und steppe noch einmal durch den Code und gehe hier jetzt in die Methode, hier wird jetzt was ausgerechnet und returned an der Stelle. Und bevor ich jetzt hier diese Zeile weitersteppe mit F11, sehe ich hier eine Neuerung im Visual Studio 2013, das heißt, an der Stelle wird mir in dem Auo-Window einmal kurz angezeigt, was denn der aktuelle Aufruf, den ich hier gemacht habe tatsächlich für einen Wert zurückgeliefert hat bevor er hier dem Result zugewiesen wird. Man sieht Result ist 0 und hier der zurückgegebene Wert von DoBar an der Stelle ist 10. Also kann ich jetzt hier mit F11 weitersteppen und dann ist meine Anwendung auch beendet. Das war also der Einzelschritt und das Untersuchen von Variablen, das Exception-Fenster und hier der Rückgabewert von Methoden im Auto-Window. Wenn ich mir jetzt die anderen Operationen anschaue, die ich hier machen konnte, "Prozedurschritt" und "Rücksprung über Prozedurschritt" hieß der andere, dann haben wir einen davon abgehakt, wir schauen uns auch die anderen beiden an. Das eine ist das sogenannante Prozedurschritt. Wir haben eben gesehen, wenn ich jetzt an dieser Stelle mit F11 weitersteppe springe ich in die Methode hinein. Ein Prozedurschritt heißt, dass diese Methode die wir jetzt hier sehen im Hintergrund ausgeführt wird und sobald die Methode wieder vom Aufruf zurückkehrt, ist der Debugger wieder da und macht weiter. Das heißt, ich drücke jetzt F10, diese Methode wird im Hintergrund ausgeführt und das nächste was wir sehen werden, ist das hier als Ergebnis 10 in unserem Result drinsteht, also ich drücke F10 und wir sehen hier die Methode wird ausgeführt und wir haben Ergebnis 10 erhalten, das heißt, wir überspringen quasi die Ausführung dieser Methode im Debugger, lassen das ganze im Hintergrund ausführen ohne das wir debuggen und bei Rücksprung dieser Methode setzt der Debugge wieder ein und wir können weiter navigieren. Das ist der Prozedurschritt. Jetzt gib es natürlich auch noch diese dritte Variante, also die Methode, dass man aus Prozeduren zurückspringen kann, ich springe jetzt hier in dieser Methode mit F11 hinein und jetzt kann es ja sein, dass man festgestellt hat ach in die Methode hier wollte ich gar nicht rein, ich möchte jetzt,dass der ganze Rest der Methode ausgeführt wird und erst wenn der wieder zum Aufrufpunkt zurückspringt, möchte ich, dass der Debugger wieder für mich kontrollierbar ist, dann nehme ich Schift+F11 und dann springt er aus dieser Methode raus und dann ist die Methode oder der Rest der Methode der unterhalb des Cursors war, im Hintergrund abgearbeitet und ich habe hier wieder mein Result 10. Wir haben uns in diesem Video mal angeschaut, wie die Grundlagen im Debugger bei Visual Studio2013 funktionieren, wir haben gesehen, wir müssen Break-Punkte setzen, damit die Anwendung an der Stelle angehalten wird und danach haben wir die Möglichkeit mit F10, F11 und Shift+F11 durch unseren Code zu navigieren, Mit F10 mache ich einen Einzelschritt und bei einer entsprechenden Methode oder Konstruktor springe ich in diesen Konstruktor oder Methode hinein, mit F10 überspringe ich diese Aufrufe und kehre dann am Ende des Aufrufs quasi im Debugger wieder zu diesem Aufruf zurück und als letztes haben wir gesehen, dass wir nicht irrtümlich in eine Methode gegangen bin und den Rest unter meinem Cursor ausführen möchte, mache ich das Ganze mit Shift+F11. Zusätzlich haben wir das erste Window kennen gelernt, das Auto-Window und im Auto-Window kann ich mir immer die aktuellen Variablen des aktuellen Scops anzeigen lassen, um zusätzlich, wenn ich grade noch in der Ausführungszeile bin, auch Rückgabewerte von Methoden, das ist neu in Visual Studio2013.

Derzeit sind keine Feedbacks vorhanden...
 

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!