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 eine allgemeine Ansicht der Debuggerfeatures wünschen, lesen Sie die Übersicht über den Visual Studio-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.

• Durchlaufen Sie Ihren Code, und sehen Sie sich die werte an, die in Variablen gespeichert sind.
• Legen Sie Überwachungen auf Variablen fest, um zu sehen, wann sich Werte ändern.
• Überprüfen Sie den Ausführungspfad des Codes, um festzustellen, ob eine Codeverzweigung ausgeführt wird.

Wenn dies das erste Mal ist, dass Sie versucht haben, Code zu debuggen, möchten Sie vielleicht Debugging für absolute Anfänger lesen.

Obwohl die Demo-App in diesem Artikel Visual Basic verwendet, gelten die meisten Features für C#, C++, F#, Python, JavaScript und andere von Visual Studio unterstützte Sprachen. 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 lernen Sie Folgendes:

• Starten des Debuggers und Erreichen von Haltepunkten
• 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 installiert haben, einschließlich der plattformübergreifenden .NET Core-Entwicklungsarbeitsauslastung .

• Wenn Sie Visual Studio installieren müssen, finden Sie informationen zu einer kostenlosen Version unter Visual Studio-Downloads.
• 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. Wählen Sie beispielsweise die Workload .NET-Desktopentwicklung aus, und klicken Sie anschließend auf Ändern.

Erstellen eines Projekts

Erstellen Sie zunächst ein .NET Core-Konsolenanwendungsprojekt. Der Projekttyp enthält alle benötigten Vorlagendateien, bevor Sie sogar etwas hinzufügen!

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.

3. Geben Sie im Suchfeld im Fenster "Neues Projekt erstellen" Konsole 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.

   

   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.

4. Geben Sie im Fenster " Neues Projekt konfigurieren" für den Projektnamen"Get-started-debugging" ein. Wählen Sie anschließend Weiter aus.

5. Stellen Sie im Fenster "Zusätzliche Informationen " sicher, dass .NET 10.0 für 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 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.

   

   F5 startet die App mit dem Debugger, der an den App-Prozess angefügt ist. Bisher haben Sie nichts Besonderes getan, um den Code zu untersuchen. Die App lädt, und die Konsolenausgabe erscheint.

   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.

   

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 Ihren ausgeführten Code unterbricht. Während des Anhaltens können Sie die Werte von Variablen und das Verhalten des Arbeitsspeichers betrachten. Sie können sehen, ob eine Verzweigung von Code ausgeführt wird.

2. Drücken Sie F5 (Debug > Debuggen starten) oder die Schaltfläche "Debuggen starten" in der Symbolleiste "Debuggen". Die App startet, und der Debugger geht zur Codezeile, wo Sie den Haltepunkt gesetzt haben.

   

   Der gelbe Pfeil stellt die Anweisung dar, auf der der Debugger angehalten wurde und die den Ausführungsprozess der App an demselben Punkt stoppt. 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 finden Sie unter Verwenden von Haltepunkten.

Navigieren von Code im Debugger mithilfe von Schrittbefehlen

In diesem Artikel werden die Tastenkombinationen verwendet, da es eine gute Möglichkeit ist, schnell ihre App im Debugger auszuführen. Es zeigt entsprechende Befehle, z. B. Menübefehle, in Klammern an.

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.

   

   F11 ist der Befehl "Schritt in ". Die App führt die Ausführung jeweils um eine Anweisung fort. F11 ist eine gute Möglichkeit, den Ausführungsfluss im Detail zu untersuchen. Standardmäßig überspringt der Debugger den Nichtbenutzercode. Weitere Informationen finden Sie unter Just My Code.

   Angenommen, Sie sind damit fertig, die SendMessage-Methode zu untersuchen, und 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 App-Ausführung fortgesetzt und der Debugger vorangetrieben, bis die aktuelle Methode oder Funktion zurückkehrt.

   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.

   

   Diesmal tritt der Debugger nicht in die SendMessage Methode ein. F10 führt den Debugger weiter aus, ohne in die Funktionen oder Methoden im Anwendungscode zu gehen. Der Code wird weiterhin ausgeführt. Durch Drücken von F10 für den SendMessage Methodenaufruf anstelle von F11 übersprungen Sie den Implementierungscode für SendMessage. Weitere Informationen zu verschiedenen Möglichkeiten zum Navigieren im Code finden Sie unter Navigieren von Code im Debugger.

Navigieren im Code mit 'Klicken zum Ausführen'

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 Ausführung bis hierhin starten.

   

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, den Sie in einer beliebigen geöffneten Datei auswählen können.

Schnelles Neustarten der App

Um die App neu zu starten, drücken Sie die Tastenkombination STRG + UMSCHALT + F5 . Sie spart Zeit, anstatt die App zu beenden und den Debugger neu zu starten. 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

Der Debugger verfügt über Features, mit denen Sie Variablen überprüfen können. Es gibt verschiedene Möglichkeiten zum Überprüfen von Variablen. 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. Der Standardwert, der Wert des ersten Elements im Array, "f"cwird angezeigt.

2. Zeigen Sie als Nächstes auf die name Variable, um den aktuellen Wert anzuzeigen, 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.

   

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

   Beim Debuggen von Code möchten Sie eine schnelle Möglichkeit, die Eigenschaftswerte von Variablen zu überprüfen, um festzustellen, ob sie die erwarteten Werte speichern. 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 vorhergehenden Zeile verwendet werden. Überprüfen Sie die Dokumentation auf sprachspezifisches Verhalten.

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.

   

   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 .

   

   Im Fenster Aufrufstapel- wird die Reihenfolge angezeigt, in der Methoden und Funktionen aufgerufen werden. Die oberste Zeile zeigt die aktuelle Funktion an. In diesem Beispiel ist es die SendMessage Methode. Die zweite Zeile zeigt, dass SendMessage von der Main Methode aufgerufen wurde usw.

   Hinweis

   Das Fenster "Aufrufstapel" ähnelt der Debug-Perspektive in einigen Programmiertools 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 Ausführungspunkt am linken Rand zu greifen, und ziehen Sie diesen eine Zeile nach oben zur 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 verschiedene Codeausführungspfade testen oder Code erneut ausführen, ohne den Debugger neu zu starten.

   Warnung

   Häufig müssen Sie mit diesem Feature vorsichtig sein. In der QuickInfo wird eine Warnung angezeigt. 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!

Verwandte Inhalte

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.

Übersicht über den Visual Studio-Debugger