Lernprogramm: Debuggen von C#-Code mithilfe von Visual Studio

In diesem Artikel werden die Features des Visual Studio-Debuggers in einer schrittweisen exemplarischen Vorgehensweise vorgestellt. Wenn Sie eine höhere Übersicht über die Debugger-Funktionen wünschen, sehen Sie sich Erster Einblick in den Debuggeran. Wenn Sie Ihre App debuggen, bedeutet das in der Regel, dass Sie Ihre 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 Sie bei dieser Übung zum ersten Mal versuchen, Code zu debuggen, möchten Sie vielleicht Debugging für absolute Anfänger lesen, bevor Sie diesen Artikel durchgehen.

Obwohl die Demo-App C# ist, gelten die meisten Features für C++, Visual Basic, 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 "Automatisch" nicht). Die Screenshots befinden sich in C#.

In diesem Tutorial werden Sie:

• Starten des Debuggers und Treffen der Breakpoints.
• Lernen Sie Befehle, um Code im Debugger schrittweise durchzugehen.
• Überprüfen von Variablen im Fenster für Datentipps und im Debugger-Fenster
• Überprüfen der Aufrufliste

Voraussetzungen

Sie müssen Visual Studio 2022 und die Workload für die .NET-Desktopentwicklung installiert haben.

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

Wenn Sie Visual Studio bereits verwenden, aber die Workload .NET-Desktopentwicklung nicht installiert ist, wechseln Sie zu Extras>Tools und Features abrufen, um den Visual Studio-Installer zu starten. Wählen Sie anschließend im Visual Studio-Installer die Workload .NET Desktopentwicklung aus, und klicken Sie dann 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 Datei>Startfensteraus.

2. Wählen Sie im Startfenster Neues Projekt erstellenaus.

3. Geben Sie im Fenster Neues Projekt erstellen im Suchfeld den Begriff Konsole ein. Wählen Sie als Nächstes C#- aus der Liste "Sprache" aus, und wählen Sie dann in der Liste "Plattform" Windows aus.

   Nachdem Sie die Sprach- und Plattformfilter angewendet haben, wählen Sie die Vorlage Konsolen-App aus, und wählen Sie dann Nextaus.

   

   Anmerkung

   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 Sie finden nicht, 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 Konfigurieren des neuen ProjektsGetStartedDebugging im Feld Projektname ein. Wählen Sie dann Weiteraus.

5. Stellen Sie im Fenster Zusätzliche Informationen sicher, dass .NET 8.0- im Dropdownmenü Framework ausgewählt ist, und wählen Sie dann Erstellenaus.

Visual Studio öffnet Ihr neues Projekt.

Erstellen der Anwendung

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

using System;

class ArrayExample
{
   static void Main()
   {
      char[] letters = { 'f', 'r', 'e', 'd', ' ', 's', 'm', 'i', 't', 'h'};
      string name = "";
      int[] a = new int[10];
      for (int i = 0; i < letters.Length; i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
      Console.ReadKey();
   }

   static void SendMessage(string name, int msg)
   {
      Console.WriteLine("Hello, " + name + "! Count to " + msg);
   }
}

Starten Sie den Debugger!

Hauptsächlich verwenden wir hier Tastenkombinationen, da es eine schnelle Möglichkeit zum Ausführen von Debuggerbefehlen ist. Entsprechende Befehle, z. B. Symbolleisten- oder Menübefehle, werden ebenfalls angegeben.

1. Um den Debugger zu starten, wählen Sie F5aus, oder wählen Sie die Schaltfläche Debugziel- auf der Standardsymbolleiste aus, oder wählen Sie in der Menüleiste die Schaltfläche Debuggen starten oder Debuggen>Debuggen starten aus der Menüleiste aus.

   

   F5 startet die App mit dem Debugger, der an den App-Prozess angefügt ist. Da wir nichts Spezielles getan haben, um den Code zu untersuchen, läuft die App bis zum Ende 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
   

2. Um den Debugger zu beenden, wählen Sie Shift+F5aus, oder wählen Sie die Schaltfläche Debuggen stoppen auf der Symbolleiste "Debuggen" aus, oder wählen Sie Debuggen>Debuggen stoppen in der Menüleiste aus.

   

3. Wählen Sie im Konsolenfenster einen beliebigen Schlüssel aus, 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 auf den linken Rand der folgenden Codezeile klicken.

   name += letters[i];

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

   

   Haltepunkte sind ein wesentliches Feature für zuverlässiges Debuggen. Sie können Haltepunkte festlegen, an denen Visual Studio den ausgeführten Code anhalten soll, damit Sie sich die Werte von Variablen oder das Verhalten des Arbeitsspeichers ansehen oder wissen, ob eine Verzweigung von Code ausgeführt wird.

2. Um mit dem Debuggen zu beginnen, wählen Sie F5aus, oder wählen Sie die Schaltfläche Debugziel- auf der Standardsymbolleiste aus, oder wählen Sie in der Menüleiste die Schaltfläche Debuggen starten aus, oder wählen Sie Debuggen>Debuggen starten aus. Die App startet, und der Debugger läuft bis zur Codezeile, bei der Sie den Breakpoint festgelegt haben.

   

   Der gelbe Pfeil zeigt auf die Anweisung, bei der der Debugger angehalten wurde. Die App-Ausführung wird an demselben Punkt angehalten, wobei die Anweisung noch nicht ausgeführt wird.

   Wenn die App nicht ausgeführt wird, können Sie mit F5 den Debugger starten. Dieser führt die App aus, bis der erste Breakpoint erreicht ist. Wenn die App an einem Haltepunkt angehalten wird, wird F5 die App weiter ausführen, bis sie den nächsten Haltepunkt erreicht.

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

Navigieren in Code und Überprüfen von Daten mithilfe von Datentipps

1. Während die Codeausführung bei der Anweisung name += letters[i] angehalten ist, zeigen Sie auf die Variable letters, um einen Datentipp mit der Arraygröße und dem Elementtyp (char[10]) anzuzeigen.

   Anmerkung

   Eines der nützlichsten Features des Debuggers ist die Fähigkeit, eine Variable zu untersuchen. Wenn Sie häufig versuchen, ein Problem zu debuggen, versuchen Sie, herauszufinden, ob Variablen werte haben, die Sie zu einem bestimmten Zeitpunkt erwarten. Das Anzeigen von Datentipps ist eine gute Möglichkeit, dies zu überprüfen.

2. Erweitern Sie die letters Variable, um alle Arrayelemente und deren Werte anzuzeigen.

   

3. Zeigen Sie mit der Maus auf die name Variable, um den aktuellen Wert anzuzeigen, bei dem es sich um eine leere Zeichenfolge handelt.

4. Um den Debugger zur nächsten Anweisung zu wechseln, wählen Sie F10aus, oder wählen Sie die Schaltfläche Schritt über in der Symbolleiste "Debuggen" aus, oder wählen Sie auf der Menüleiste "Debuggen>Schritt über" aus. Wählen Sie F10 zweimal mehr aus, um über den SendMessage Methodenaufruf hinaus zu wechseln.

   F10 führt den Debugger weiter, ohne in Funktion oder Methoden zu treten, obwohl ihr Code weiterhin ausgeführt wird. Auf diese Weise haben wir das Debuggen des Codes in der SendMessage-Methode übersprungen, an dem wir derzeit nicht interessiert sind.

5. Wenn Sie die for Schleife ein paar Mal durchlaufen möchten, wählen Sie F10 wiederholt aus. Halten Sie während jeder Schleifeniteration am Haltepunkt an, und bewegen Sie dann den Mauszeiger auf die Variable name, um ihren Wert im Datentipp zu überprüfen.

   

   Der Wert der Variablen ändert sich bei jeder Iteration der for Schleife und zeigt die Werte f, dann fr, dann freusw. an. Damit der Debugger die Schleife schneller durchläuft, drücken Sie stattdessen F5. Dadurch wird der Debugger bis zum nächsten Haltepunkt und nicht nur bis zur nächsten Anweisung ausgeführt.

6. Während die Codeausführung in der for-Schleife der Main-Methode angehalten wird, wählen Sie F11-, oder wählen Sie die Schaltfläche "Schritt in" auf der Debug-Symbolleiste, oder wählen Sie Debug>"Schritt in" aus der Menüleiste, bis Sie den SendMessage-Methodenaufruf erreicht haben.

   Der Debugger sollte an dieser Codezeile angehalten werden:

   SendMessage(name, a[i]);

7. Wenn Sie mit der SendMessage-Methode fortfahren möchten, wählen Sie F11 erneut aus.

   Der gelbe Zeiger wechselt zur SendMessage Methode.

   

   F11- hilft Ihnen, den Ausführungsfluss Ihres Codes genauer zu untersuchen. Um in eine Methode aus einem Methodenaufruf einzutreten, wählen Sie F11. Standardmäßig überspringt der Debugger die schrittweise Ausführung von Nichtbenutzermethoden. Informationen zum Debuggen von Nichtbenutzercode finden Sie unter Just My Code.

   Nachdem Sie das Debuggen der SendMessage-Methode abgeschlossen haben, können Sie zur for Schleife der main-Methode zurückkehren.

8. Um die SendMessage-Methode zu verlassen, wählen Sie Shift+F11aus, oder wählen Sie die Schaltfläche Schritt zurück in der Symbolleiste "Debug" aus, oder wählen Sie Debug>Schritt zurück in der Menüleiste aus.

   Durch Ausführen bis Rücksprung wird die App-Ausführung fortgesetzt und der Debugger vorgerückt, bis die aktuelle Methode oder Funktion abgeschlossen ist.

   Der gelbe Pfeil wird wieder in der for-Schleife der Methode Main angezeigt, und der Vorgang wird beim Methodenaufruf SendMessage angehalten. Weitere Informationen zu verschiedenen Möglichkeiten zum Navigieren im Code finden Sie unter Navigieren von Code im Debugger.

Navigieren durch Code mithilfe von „Ausführung bis Klick“

1. Wählen Sie F5 aus, um erneut zum Haltepunkt vorzurücken.

2. Zeigen Sie im Code-Editor mit dem Cursor auf den Methodenaufruf Console.WriteLine in der Methode SendMessage, bis die Schaltfläche Ausführung bis Klick angezeigt wird. Die QuickInfo für die Schaltfläche zeigt „Ausführung bis hier“ an.

   

3. Wählen Sie die Schaltfläche Ausführung bis Klick aus. Alternativ können Sie mit dem Cursor an der Console.WriteLine-Anweisung STRG+F10auswählen. Als weitere Alternative klicken Sie mit der rechten Maustaste auf den Methodenaufruf Console.WriteLine, und wählen Sie im Kontextmenü Ausführen bis Cursor aus.

   Der Debugger wechselt zum Console.WriteLine Methodenaufruf.

   Die Verwendung der Schaltfläche Run to Click ähnelt dem Festlegen eines temporären Haltepunkts und ist praktisch, um schnell innerhalb eines sichtbaren Bereichs Ihres App-Codes in der aktuell geöffneten Datei zu navigieren.

Schnelles Neustarten der App

Wenn Sie Ihre App von Anfang an im Debugger erneut ausführen möchten, wählen Sie STRG+UMSCHALT+F5aus, oder wählen Sie die Schaltfläche Neu starten auf der Symbolleiste "Debuggen" aus, oder wählen Sie Debuggen>Neustarten in der Menüleiste aus.

Neustarten stoppt den Debugger und startet ihn dann in einem Schritt neu. Wenn der Debugger neu gestartet wird, läuft er bis zum ersten Haltepunkt, bei dem es sich um den Haltepunkt handelt, den Sie zuvor in der for-Schleife festgelegt haben, und hält dann an.

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

Die Autos und Locals Fenster zeigen Variablenwerte an, während Sie debuggen. Die Fenster sind nur während einer Debugsitzung verfügbar. Im Autos-Fenster werden die Variablen angezeigt, die in der aktuellen Zeile verwendet werden, an der sich der Debugger befindet, sowie in der vorhergehenden Zeile. Im fenster "Locals" werden Variablen angezeigt, die im lokalen Bereich definiert sind. Dies ist in der Regel die aktuelle Funktion oder Methode.

1. Sehen Sie sich das Fenster Auto unten im Code-Editor an, während der Debugger angehalten ist.

   Wenn das Fenster Auto geschlossen ist, drücken Sie STRG+D, A, oder wählen Sie in der Menüleiste Debuggen>Fenster>Auto aus.

2. Solange der Debugger angehalten ist, zeigen Sie das Fenster Lokal auf einer Registerkarte neben dem Fenster Auto an.

   Wenn das Locals Fenster geschlossen ist, wählen Sie STRG+D, L, oder wählen Sie Debug>Windows>Locals.

3. Erweitern Sie im Fenster Locals die letters-Variable, um die Arrayelemente und deren Werte anzuzeigen.

   

Weitere Informationen zu den Fenstern Auto und Lokal finden Sie unter Untersuchen von Variablen über die Fenster „Auto“ und „Lokal“.

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 Fenster Watch hinzufügen.

1. Während der Debugger angehalten ist, klicken Sie mit der rechten Maustaste auf die Variable name, und wählen Sie Überwachung hinzufügen aus.

   Das Fenster Überwachen wird im unteren Bereich des Code-Editors geöffnet.

2. Nachdem Sie eine Überwachung für die Variable name festgelegt haben, können Sie den Code schrittweise ausführen, um zu beobachten, wie sich der Wert der Variablen name bei jeder Iteration der for-Schleife ändert.

   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 Fenster Überwachen finden Sie unter Überwachen von Variablen mit Überwachungsfenstern.

Überprüfen der Aufrufliste

Der Aufrufstapel- kann Ihnen helfen, den Ausführungsfluss Ihrer App zu verstehen, indem sie die Reihenfolge anzeigt, in der Methoden und Funktionen aufgerufen werden.

1. Während der Debugger in der for-Schleife angehalten ist, sehen Sie sich das Fenster Aufrufliste an, das standardmäßig im unteren rechten Bereich des Code-Editors geöffnet wird.

   Wenn das Fenster Aufrufliste geschlossen ist, drücken Sie STRG+D, C, oder wählen Sie in der Menüleiste Debuggen>Fenster>Aufrufliste aus.

   Im Fenster Aufrufliste befindet sich der gelbe Zeiger auf der aktuellen Methode Main.

2. Drücken Sie einige Male die Taste F11, bis der Debugger bei der Methode SendMessage anhält.

   Die oberste Zeile des Aufrufstapel- Fensters zeigt die aktuelle Funktion an, bei der es sich um die SendMessage-Methode handelt. Die zweite Zeile zeigt, dass die SendMessage-Methode aus der Main-Methode aufgerufen wurde.

   

   Anmerkung

   Das fenster Call Stack ähnelt der Debugperspektive in einigen IDEs, z. B. Eclipse.

   Im Fenster Aufrufstapel können Sie auf eine Codezeile doppelklicken, um zu diesem Quellcode zu wechseln, wodurch der aktuelle Bereich, der vom Debugger überprüft wird, geändert wird. Diese Aktion bringt den Debugger nicht voran.

   Sie können auch über die Kontextmenüs im Fenster Aufrufliste weitere Aktionen ausführen. Beispielsweise können Sie Haltepunkte in bestimmte Funktionen einfügen, den Debugger über Ausführen bis Cursor vorrücken oder in den Quellcode wechseln.

Weitere Informationen zur Aufrufliste finden Sie unter Untersuchen der Aufrufliste.

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 Blick auf den Debugger