Freigeben über

Lernprogramm: Debuggen von Visual Basic-Code mithilfe von Visual Studio

In diesem Artikel werden die Features des Visual Studio-Debuggers in einer schrittweisen exemplarischen Vorgehensweise vorgestellt. Wenn Sie einen Überblick über die Debuggerfunktionen wünschen, siehe Erster Blick auf den Debugger. Wenn Sie Ihre App debuggen, bedeutet dies in der Regel, dass Sie die Anwendung mit dem angefügten Debugger ausführen. Wenn Sie diese Aufgabe ausführen, bietet der Debugger viele Möglichkeiten, um zu sehen, was Der Code während der Ausführung ausführt. Sie können Ihren Code schrittweise durchlaufen und die in Variablen gespeicherten Werte betrachten, Sie können Überwachungen auf Variablen festlegen, um zu sehen, wann sich Werte ändern, Sie können den Ausführungspfad Ihres Codes untersuchen, sehen, ob eine Verzweigung von Code ausgeführt wird usw. Wenn diese Übung das erste Mal ist, dass Sie versucht haben, Code zu debuggen, sollten Sie das Debuggen für absolute Anfänger lesen, bevor Sie diesen Artikel durchgehen.

Obwohl die Demo-App Visual Basic ist, gelten die meisten Features für C#, C++, F#, Python, JavaScript und andere sprachen, die von Visual Studio unterstützt werden (F# unterstützt "Edit-and-continue" nicht. F# und JavaScript unterstützen das Fenster "Auto" nicht. Die Screenshots befinden sich in Visual Basic.

In diesem Tutorial werden Sie Folgendes lernen:

  • Starten Sie den Debugger, und treffen Sie Haltepunkte.
  • Erfahren Sie Befehle, um Code im Debugger schrittweise zu durchlaufen.
  • Variablen in Datentipps und Debuggerfenstern überprüfen
  • Untersuche den Aufrufstack

Voraussetzungen

Sie müssen Visual Studio 2019 installiert haben und das .NET Core Cross-Platform-Entwicklungs-Workload.

Wenn Sie Visual Studio noch nicht installiert haben, wechseln Sie zur Visual Studio-Downloads Seite, um es kostenlos zu installieren.

Wenn Sie die Workload installieren müssen, aber bereits über Visual Studio verfügen, gehen Sie zu Tools>Tools und Features abrufen..., wodurch das Visual Studio-Installationsprogramm geöffnet wird. Das Visual Studio-Installationsprogramm wird gestartet. Wählen Sie beispielsweise die Workload .NET-Desktopentwicklung aus, und klicken Sie anschließend auf Ändern.

Erstellen eines Projekts

Zuerst erstellen Sie ein .NET Core-Konsolenanwendungsprojekt. Der Projekttyp enthält alle benötigten Vorlagendateien, bevor Sie sogar etwas hinzugefügt haben!

  1. Öffnen Sie Visual Studio. Wenn das Startfenster nicht geöffnet ist, wählen Sie ">" aus.

  2. Klicken Sie im Startfenster auf Neues Projekt erstellen.

  1. Geben Sie im Fenster " Neues Projekt erstellen " die Konsole in das Suchfeld ein. Wählen Sie als Nächstes Visual Basic aus der Liste "Sprache" und dann "Windows " aus der Liste "Plattform" aus.

    Nachdem Sie die Sprach- und Plattformfilter angewendet haben, wählen Sie die Konsolen-App-Vorlage für .NET Core und dann "Weiter" aus.

    Screenshot des Fensters

    Hinweis

    Wenn die Vorlage Konsolen-App- nicht angezeigt wird, können Sie sie aus dem Fenster Erstellen eines neuen Projekts installieren. Wählen Sie in der Meldung "Nicht finden, wonach Sie suchen?" den Link "Weitere Tools und Features installieren " aus. Wählen Sie dann im Visual Studio Installer die .NET-Desktopentwicklung-Workload aus.

  2. Geben Sie im Fenster "Neues Projekt konfigurieren" im Feld "Projektname" get-started-debugging ein. Wählen Sie anschließend Weiter aus.

  3. Stellen Sie im Fenster "Zusätzliche Informationen " sicher, dass .NET 8.0 im Dropdownmenü "Framework " ausgewählt ist, und wählen Sie dann "Erstellen" aus.

Visual Studio öffnet Ihr neues Projekt.

Erstellen der Anwendung

Ersetzen Sie in Program.vb stattdessen den gesamten Standardcode durch den folgenden Code:

Imports System

Class ArrayExample
  Public Shared Sub Main()
    Dim letters As Char() = {"f"c, "r"c, "e"c, "d"c, " "c, "s"c, "m"c, "i"c, "t"c, "h"c}
    Dim name As String = ""
    Dim a As Integer() = New Integer(9) {}

    For i As Integer = 0 To letters.Length - 1
      name += letters(i)
      a(i) = i + 1
      SendMessage(name, a(i))
    Next

    Console.ReadKey()
  End Sub

  Private Shared Sub SendMessage(ByVal name As String, ByVal msg As Integer)
    Console.WriteLine("Hello, " & name & "! Count to " & msg)
  End Sub
End Class

Starten Sie den Debugger!

  1. Drücken Sie F5 (Debug > Debugging starten) oder wählen Sie die grüne Schaltfläche "Debuggen starten" in der Debugsymbolleiste aus.

    Screenshot der Debugsymbolleiste mit hervorgehobener grüner Schaltfläche

    F5 startet die App mit dem Debugger, der an den App-Prozess angefügt ist, aber im Moment haben wir nichts Besonderes getan, um den Code zu untersuchen. Die App lädt einfach und die Konsolenausgabe wird angezeigt.

    Hello, f! Count to 1
Hello, fr! Count to 2
Hello, fre! Count to 3
Hello, fred! Count to 4
Hello, fred ! Count to 5
Hello, fred s! Count to 6
Hello, fred sm! Count to 7
Hello, fred smi! Count to 8
Hello, fred smit! Count to 9
Hello, fred smith! Count to 10

    In diesem Lernprogramm werfen Sie einen genaueren Blick auf diese App mithilfe des Debuggers und werfen einen Blick auf die Debuggerfeatures.

  2. Beenden Sie den Debugger, indem Sie (UMSCHALT + F5) drücken oder die rote Schaltfläche " Debuggen beenden " in der Debugsymbolleiste auswählen.

    Screenshot der Debugsymbolleiste mit hervorgehobener roter Schaltfläche

  3. Drücken Sie im Konsolenfenster eine Taste, um das Konsolenfenster zu schließen.

Festlegen eines Haltepunkts und Starten des Debuggers

  1. Legen Sie in der For Schleife der Main Funktion einen Haltepunkt fest, indem Sie in der folgenden Codezeile auf den linken Rand klicken:

    name += letters(i)

    An der Stelle, an der Sie den Haltepunkt festlegen, wird ein roter Kreis angezeigt.

    Haltepunkte sind ein einfaches und wichtiges Feature zum zuverlässigen Debuggen. Ein Haltepunkt gibt an, wo Visual Studio den ausgeführten Code anhalten soll, damit Sie sich die Werte von Variablen oder das Verhalten des Arbeitsspeichers ansehen können oder ob ein Codezweig ausgeführt wird.

  2. Drücken Sie F5 (Debug > Debuggen starten) oder die Schaltfläche Debuggen starten in der Debugsymbolleiste, wird die App gestartet, und der Debugger läuft bis zu der Codezeile, in der Sie den Haltepunkt festgelegt haben.

    Screenshot des Editor-Fensters von Visual Studio Code mit gestoppter Ausführung an einem Haltepunkt.

    Der gelbe Pfeil stellt die Anweisung dar, auf dem der Debugger gestoppt wurde, was auch die App-Ausführung an demselben Punkt unterbricht (diese Anweisung wird noch nicht ausgeführt).

    Wenn die App noch nicht ausgeführt wird, startet F5 den Debugger und stoppt am ersten Haltepunkt. Andernfalls läuft F5 die App bis zum nächsten Haltepunkt weiter.

    Haltepunkte sind ein nützliches Feature, wenn Sie die Codezeile oder den Codeabschnitt kennen, den Sie im Detail untersuchen möchten. Informationen zu den verschiedenen Typen von Haltepunkten, die Sie festlegen können, z. B. bedingte Haltepunkte, finden Sie unter Verwenden von Haltepunkten.

In diesem Artikel verwenden wir die Tastenkombinationen, da es eine gute Möglichkeit ist, die Ausführung Ihrer App im Debugger schnell auszuführen (entsprechende Befehle wie Menübefehle werden in Klammern angezeigt).

  1. Während die Codeausführung in der Schleife der ForMain Methode angehalten wird, drücken Sie F11 (oder wählen Sie zweimal Debug > Step Into aus), um zum Aufruf der Methode SendMessage fortzufahren.

    Nachdem Sie F11 zweimal gedrückt haben, sollten Sie sich auf dieser Codezeile befinden:

    SendMessage(name, a(i))

  2. Drücken Sie F11 noch einmal, um in die SendMessage Methode einzutreten.

    Der gelbe Zeiger wechselt zur SendMessage Methode.

    Screenshot einer Debugsitzung im Visual Studio Code-Editor mit angehaltener Ausführung nach dem Ausführen der Methode

    F11 ist der Befehl "Schritt in " und setzt die App-Ausführung jeweils um eine Anweisung fort. F11 ist eine gute Möglichkeit, den Ausführungsfluss im Detail zu untersuchen. (Um schneller durch Code zu navigieren, zeigen wir Ihnen auch einige andere Optionen.) Standardmäßig überspringt der Debugger Nichtbenutzercode (wenn Sie weitere Details wünschen, lesen Sie just My Code).

    Angenommen, Sie sind damit fertig, die SendMessage Methode zu untersuchen, und Sie möchten die Methode verlassen, aber im Debugger bleiben. Dazu können Sie den Befehl " Aussteigen" verwenden.

  3. Drücken Sie UMSCHALT + F11 (oder Debug >-Schritt beenden).

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

    Sie sollten in der Schleife der ForMain Methode zurück sein, angehalten am SendMessage Methodenaufruf.

  4. Drücken Sie F11 mehrmals, bis Sie wieder zum SendMessage Methodenaufruf zurückkehren.

  5. Während die Codeausführung beim Methodenaufruf angehalten wird, drücken Sie einmal F10 (oder wählen Sie Debug > Step Over) aus.

    Screenshot einer Debugsitzung im Visual Studio Code-Editor mit angehaltener Ausführung nach dem Durchlaufen des Methodenaufrufs

    Beachten Sie dieses Mal, dass der Debugger nicht in die SendMessage-Methode wechselt. F10 führt den Debugger weiter, ohne in Ihren App-Code zu wechseln (der Code wird weiterhin ausgeführt). Durch Drücken von F10 für den SendMessage Methodenaufruf (anstelle von F11) haben wir den Implementierungscode SendMessage übersprungen (für den wir derzeit vielleicht nicht interessiert sind). Weitere Informationen zu verschiedenen Möglichkeiten zum Navigieren im Code finden Sie unter Navigieren von Code im Debugger.

  1. Drücken Sie F5 um erneut zum Haltepunkt fortzufahren.

  2. Scrollen Sie im Code-Editor nach unten und fahren Sie mit der Maus über die Methode Console.WriteLine in der Methode SendMessage, bis die grüne Schaltfläche "Ausführen bis Klick" angezeigt wird. Die QuickInfo für die Schaltfläche zeigt "Bis hierher ausführen".

    Screenshot der Schaltfläche „Ausführen bis zum Klicken“ mit hervorgehobener QuickInfo auf der linken Seite des Code-Editor-Fensters.

  3. Wählen Sie die Schaltfläche Run to Click aus.

    Der Debugger wechselt zur Console.WriteLine Methode.

    Die Verwendung dieser Schaltfläche ähnelt dem Festlegen eines temporären Haltepunkts. Run to Click ist praktisch, um schnell innerhalb eines sichtbaren Bereichs von App-Code zu navigieren (Sie können in jeder geöffneten Datei auswählen).

Schnelles Neustarten der App

Um die App neu zu starten, drücken Sie die Tastenkombination STRG + UMSCHALT + F5. Das spart Zeit im Vergleich zur Beendigung der App und dem Neustart des Debuggers. Der Debugger hält am ersten Haltepunkt an, der bei der Codeausführung erreicht wird.

Der Debugger wird wieder an dem Haltepunkt beendet, den Sie zuvor in der For Schleife festgelegt haben.

Überprüfen von Variablen mit Datentipps

Features, mit denen Sie Variablen überprüfen können, sind eines der nützlichsten Features des Debuggers, und es gibt verschiedene Möglichkeiten, dies zu tun. Wenn Sie häufig versuchen, ein Problem zu debuggen, versuchen Sie herauszufinden, ob Variablen die Werte speichern, die sie zu einem bestimmten Zeitpunkt haben sollen.

  1. Während die Codeausführung für die name += letters[i] Anweisung angehalten wird, zeigen Sie mit der Maus auf die letters Variable, und sie sehen den Standardwert, den Wert des ersten Elements im Array. "f"c

  2. Zeigen Sie als Nächstes auf die name Variable, und sie sehen den aktuellen Wert, eine leere Zeichenfolge.

  3. Drücken Sie F5 (oder Debuggen>fortsetzen), um mehrmals durch die For Schleife zu durchlaufen, an dem Haltepunkt wieder anzuhalten und jedes Mal auf die name Variable zu zeigen, um den Wert zu überprüfen.

    Screenshot mit beendeter Debugausführung im Code-Editor mit hervorgehobener Namensvariable und einem Datentipp mit dem Wert.

    Der Wert der Variablen ändert sich bei jeder Iteration der For-Schleife, wobei die Werte f, dann fr, dann freusw. angenommen werden.

    Beim Debuggen wollen Sie oft eine schnelle Möglichkeit, die Eigenschaftswerte von Variablen zu überprüfen, um festzustellen, ob sie die erwarteten Werte speichern, und Datentipps sind eine gute Möglichkeit, dies zu tun.

Überprüfen von Variablen mit den Fenstern "Autos" und "Locals"

  1. Sehen Sie sich das Fenster "Autos" unten im Code-Editor an.

    Wenn sie geschlossen ist, öffnen Sie sie, während die Codeausführung im Debugger angehalten wird, indem Sie"Windows>Autos> auswählen.

    Im Fenster "Autos " werden Variablen und deren aktueller Wert angezeigt. Im Fenster "Autos " werden alle Variablen angezeigt, die in der aktuellen Zeile oder in der vorherigen Zeile verwendet werden (Dokumentation zu sprachspezifischem Verhalten überprüfen).

  2. Sehen Sie sich als Nächstes das Fenster " Lokal" auf einer Registerkarte neben dem Fenster " Autos " an.

  3. Erweitern Sie die letters Variable, um die darin enthaltenen Elemente anzuzeigen.

    Screenshot des Lokalen Fensters mit erweiterter Variable

    Im Fenster Lokal werden Ihnen die Variablen angezeigt, die sich im aktuellen Bereich befinden, also im aktuellen Ausführungskontext.

Eine Uhr stellen

Sie können eine Variable oder einen Ausdruck angeben, die Sie beim Durchlaufen von Code im Auge behalten möchten, indem Sie sie dem Überwachungsfenster hinzufügen.

  1. Klicken Sie während der Pause des Debuggers mit der rechten Maustaste auf die name Variable, und wählen Sie "Überwachung hinzufügen" aus.

    Das Überwachungsfenster wird standardmäßig unten im Code-Editor geöffnet.

  2. Nachdem Sie nun eine Überwachung für die name-Variable festgelegt haben, durchlaufen Sie Ihren Code, um die Änderung des Werts der name-Variable mit jeder for-Schleifeniteration zu sehen.

    Im Gegensatz zu den anderen Variablenfenstern zeigt das Überwachungsfenster immer die Variablen an, die Sie beobachten. Variablen, die außerhalb des Gültigkeitsbereichs liegen, werden als nicht verfügbar angezeigt.

Weitere Informationen zum Überwachungsfenster finden Sie unter Überwachungsvariablen mit Überwachungsfenstern.

Untersuche den Aufrufstack

  1. Während die Codeausführung in der For Schleife angehalten wird, wählen Sie das Call Stack-Fenster aus, das standardmäßig im unteren rechten Bereich geöffnet ist.

    Wenn sie geschlossen ist, öffnen Sie sie, während die Codeausführung im Debugger angehalten wird, indem Sie "Windows-Aufrufstapel>> auswählen.

  2. Wählen Sie F11 ein paar Mal aus, bis der Debugger in der SendMessage Methode angehalten wird. Sehen Sie sich das Fenster "Anrufliste" an .

    Screenshot des Visual Studio-Anrufstapelfensters mit hervorgehobenem SendMessage-Methodenaufruf in der obersten Zeile.

    Im Fenster Aufrufstapel- wird die Reihenfolge angezeigt, in der Methoden und Funktionen aufgerufen werden. Die oberste Zeile zeigt die aktuelle Funktion (die SendMessage Methode in dieser App). Die zweite Zeile zeigt, dass SendMessage von der Main Methode aufgerufen wurde usw.

    Hinweis

    Das -Aufrufstapel--Fenster ähnelt der Debug-Perspektive in einigen IDEs wie Eclipse.

    Der Aufrufstapel ist eine gute Möglichkeit, den Ausführungsfluss einer App zu untersuchen und zu verstehen.

    Sie können auf eine Codezeile doppelklicken, um den Quellcode anzuzeigen, und dies ändert auch den aktuellen Bereich, der vom Debugger überprüft wird. Diese Aktion führt nicht zur Weiterführung des Debuggers.

    Sie können auch über die Kontextmenüs im Fenster Aufrufliste weitere Aktionen ausführen. Sie können z. B. Haltepunkte in bestimmte Funktionen einfügen, den Debugger mithilfe von "Ausführen zum Cursor" voranbringen und den Quellcode untersuchen. Weitere Informationen finden Sie unter How to: Examine the Call Stack.

Ändern des Ausführungsflusses

  1. Drücken Sie zweimal F11 , um die Console.WriteLine Methode auszuführen.

  2. Wenn der Debugger im SendMessage Methodenaufruf angehalten wurde, verwenden Sie die Maus, um den gelben Pfeil oder den Ausführungspunkt (im linken Rand) zu greifen, und ziehen Sie den Zeiger um eine Zeile nach oben an die Console.WriteLine Anweisung.

  3. Drücken Sie F11.

    Der Debugger wird die Console.WriteLine Methode erneut ausführen (diese Aktion wird in der Konsolenfensterausgabe angezeigt).

    Durch Ändern des Ausführungsflusses können Sie z. B. verschiedene Codeausführungspfade testen oder Code erneut ausführen, ohne den Debugger neu zu starten.

    Warnung

    Oft müssen Sie mit dieser Funktion vorsichtig sein, und Sie sehen eine Warnung im Tooltip. Möglicherweise werden auch andere Warnungen angezeigt. Durch Das Verschieben des Zeigers kann Ihre Anwendung nicht in einen früheren App-Zustand zurückgesetzt werden.

  4. Drücken Sie F5 , um die Ausführung der App fortzusetzen.

    Herzlichen Glückwunsch zum Abschluss dieses Lernprogramms!

Nächste Schritte

In diesem Lernprogramm haben Sie gelernt, wie Sie den Debugger starten, Code durchlaufen und Variablen überprüfen. Möglicherweise möchten Sie einen allgemeinen Einblick in die Debuggerfeatures sowie Links zu weiteren Informationen erhalten.

Erster Einblick in den Debugger

  • Last updated on