Visual C# 2011 Grundkurs

Debugging: Erweiterte Techniken

LinkedIn Learning kostenlos und unverbindlich testen!

Jetzt testen Alle Abonnements anzeigen
Ein guter Entwickler beherrscht neben den Grundlagen des Debugging weitere Tricks und Kniffe, um Fehler noch schneller zu finden. Ein paar davon sehen Sie hier am praktischen Beispiel.
06:10

Transkript

Im folgenden Video schauen wir uns erweiterte Funktionalitäten des "Debuggers" von Vision Studio an. "Debuggen" ist eine wichtige Tätigkeit im Leben eines Entwicklers und Sie werden wahrscheinlich mehr Zeit mit dem "Debuggen" verbringen, als Ihnen lieb ist. Deswegen ist es durchaus wichtig, dass man diesen "Debugger" zum Einen beherrscht und zweitens auch ein paar Tricks und Kniffe mit diesem "Debugger" kennt. Als erstes schauen wir uns das Ausgeben von Debug-Informationen  an. Bisher haben wir immer Informationen in der Konsole ausgegeben. Mit der Methode "WriteLine" der Klasse "Konsole". Nun möchten wir manchmal Informationen ausgeben, z.B. Inhalt von Variablen oder, dass eine gewisse Methode erreicht wurde, die eben nicht unbedingt in der Konsole erscheinen soll, wir diese Information aber trotzdem bekommen möchten. Deswegen gibt es die Klasse "Debug". Und in dieser Klasse "Debug" gibt es eine Methode "WriteLine". Und diese Methode "RiotLine" macht eben nichts anderes, als das was wir von der Konsole gewöhnt sind. Allerdings wird dieser Text nicht in der Konsole ausgegeben, sondern hier unten im Ausgabefenster. Wir führen das Programm einmal aus: Wir sitzen vor einem "Breakpoint", durch Klicken hier auf diesen grauen Bereich. Ich führe das Programm aus, und wir sehen hier in dem Ausgabefenster sind schon sehr viele Informationen enthalten. Das sind hauptsächlich vom Compiler generierte Meldungen und durch Drücken von "F11" springen wir jetzt in die nächste Zeile. Sie sehen hier unten, dass meine "Textausgabe" nur im Debug-Fenster jetzt hier unten im Fenster ausgegeben wurde. In der Konsole, die wir natürlich nun auch im Hintergrund haben - allerdings ohne Text, weil wir noch nichts ausgegeben haben - steht diese Meldung eben nicht. Ein anderes sehr nützliches Feature ist das "Direkt-Fenster". Das "Direkt-Fenster" finden Sie unten rechts, oder wenn es noch nicht aktiviert ist, bei "Debuggen", dann "Fenter", und dann "Direkt". Im "Direkt-Fenster" kann ich direkt Befehle oder Kommandos eintippen, die dann ausgewertet werden. Z.B. könnte ich jetzt hier mir durch Eintippen von "Number" den Wert von "Number" einzeigen lassen. Der ist noch "Null". Jetzt könnte ich z.B. an dieser Stelle durch drücken von "F10" ihn dann mal einen Wert schreiben lassen. Wenn ich mir dann nochmal "Number" ausgeben lasse, dann bekomme ich den Wert "6". Zusätzlich kann ich an dieser Stelle auch Methoden ausführen. Ich könnte z.B. sagen: "Konsole" und dann "WriteLine", Sie sehen auch hier gibt es "Intellisens". Dann gebe ich den Wert von "Number" aus. Dann steht hier: "Der Auszug wurde ausgewertet und weist keinen Fehler auf." Wenn ich mir die Konsole angucke, dann wurde dort der Wert "6" ausgegeben. Mit diesem Tool muss man sehr vorsichtig sein, weil man sich immer genau dessen bewusst sein muss, was man dort macht, wenn man wirklich den Inhalt von Variablen verändert. Wenn man eine Methode aufruft, die eventuell etwas in die Datenbank schreibt, dann wird es auch tatsächlich in die Datenbank geschrieben. Das ist jetzt nicht irgendwie etwas was separat von unserem Programm läuft. Es läuft wirklich tatsächlich im Programm.  Als nächstes möchte ich mal ein "Feature" zeigen. Zu diesem "Feature" habe ich zwei Methoden geschrieben. Zum Einen, eine Methode "Dummy A", die bekommt einen Parameter übergeben, und diese ruft wiederum eine Methode "Dummy B" auf, ebenfalls mit einem Parameter. In der Methode "Dummy B" wird auch wieder ein Parameter entgegen genommen und ein Text ausgegeben. Hier oben an der Aufrufstelle springe ich jetzt mal mit "F11" in diese Methoden rein. Hier bin ich in der Methode "Dummy A", dort wird "Dummy B" aufgerufen, auch da springe ich rein. Jetzt bin ich hier drin. Das wird sehr oft passieren, dass wir eine sehr lange Aufrufkette von diesen Methoden haben, Sie sich dann in irgendeiner Methode befinden und sich denken: Wie bin ich überhaupt dahin gekommen? Wie wurde jetzt diese Methode aufgerufen und mit welchen Werten wurde diese Methode überhaupt aufgerufen?  Dafür gibt es die "Aufrufliste". In der "Aufrufliste" sehen Sie genau welche Methoden aufgerufen werden. Wir sehen hier die komplette Aufruf-Reihenfolge, mit der aktuellen Methode an der obersten Stelle und mit der ursprünglichen Methode an der untersten Stelle. Sie sehen hier, das Ganze ging von der "Main-Funktion" aus, danach wurde der "Dummy A" aufgerufen und von "Dummy A" wurde "Dummy B" aufgerufen.  Das ist natürlich schon ein sehr nützliches "Feature". Was natürlich noch besser ist, ich kann durch Klicken auf die jeweilige Zeile in die Aufrufzeile springen. Sie sehen: hier bin ich in der Aufrufzeile von "Dummy B", könnte mir jetzt hier auch die jeweiligen Werte der Parameter angucken. Dasselbe könnte ich machen, indem ich hier in die "Main-Funktion"  zurückspringe und auch hier könnte ich mir das angucken. Bin natürlich weiter mit meinem Programm hier unten, da geht es eben nur darum, dass ich mir angucken kann, von welchen Stellen wurden diese Methoden mit welchen Werten aufgerufen. Ich springe wieder mit "F11" aus dieser Methode hinaus. Beenden hier Methode "Dummy A" und sind wieder in unserer Main-Methode. Jetzt gibt es durchaus mal Situationen, wo ich mit meinem Quellcode sehe: Ah, das könnte der Fehler sein und das müsste hier eine "8" sein. Das Schöne ist bei Visiual Studio, ich kann das direkt in eine "8" ändern. Jetzt müsste ich natürlich den Programmteil nochmal ausführen, um diesen Wert von "Number" ändern zu können oder alles was dazwischen noch kommt. Nun das ist auch relativ einfach, hier vorne ist ja unser "Debugging-Cursor", ich kann jetzt an dieser Stelle - man sieht das durch den Cursor, der Pfeil nach oben und unten hat - diesen "Debugging-Cursor" an eine x-beliebige Stelle verschieben. Führe die aktuelle Zeile erstmal noch aus, dann nehme ich diesen "Debug-Cursor" und schiebe ihn hier auf diese Zeile. Man sieht, dass der Cursor jetzt auf dieser Zeile ist, "Number" hat noch den Wert "6" und sobald ich diese Zeile ausführe, hat "Number" den Wert "8". Ein Weiteres was beim "Debugging" wichtig ist, ist das lokale Fenster. Ein "Lokalfenster", hier unten links auf dieser Seite, oder wenn es nicht angezeigt wird, über "Debuggen", "Fenster" und dann "Lokal", können wir uns den Wert der lokalen Variablen innerhalb dieser Methode anzeigen lassen. Wenn ich hier draufgehe sehe ich genau, in dieser Methode, wo sich mein Cursor gerade befindet, sind zwei Variablen aktiv. Es ist zum Einen hier oben, die Argumente, die der "Main-Methode" übergeben wurden und eben meine Variable "Number" mit dem Wert "8". Ebenfalls noch sehr nützlich, ist das "Überwachen". Ich könnte jetzt rechts einen Klick auf diese Variable machen, sagen: "Überwachungen hinzufügen" und dann wird mir unten im Überwachen-Fenster nur noch diese eine Variable angezeigt, mit dessen Wert. Ich kann dann mit "F11" durch meine Methode navigieren und sehe immer den aktuellen Wert dieser Variablen, die ich beobachte. Wir haben uns in diesem Video  einmal die erweiterten "Debugging-Funktionalitäten" von Visual Studio angeguckt. Wir haben gesehen, dass wir Debugging-Meldungen in einem speziellen Ausgabefenster anzeigen können, dass wir mit dem "Direkt-Fenster" direkt den Inhalt von Variablen ändern können und direkt Methoden aufrufen können, dass wir mit der Aufrufliste schauen können von wo eine Methode aufgerufen wurde, mit welchen Parametern. Wir haben gesehen, dass wir den Zeiger hin- und herschieben können und dabei Teile unseres Quelltextes verändern können und schlussendlich, dass wir mit den Fenstern "Lokal" und "Überwachen" den Wert von lokalen Variablen und Feldern in Klassen überwachen können.

Visual C# 2011 Grundkurs

Steigen Sie in die C#-Programmierung ein und lernen Sie sowohl die Grundlagen der Sprache C# als auch die Entwicklungsumgebung Visual Studio 2010 und .NET-Framework kennen.

7 Std. 28 min (81 Videos)
Derzeit sind keine Feedbacks vorhanden...
Hersteller:
Software:
Visual Studio Visual Studio 2010
Exklusiv für Abo-Kunden
Erscheinungsdatum:27.06.2011

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!