Tutorial: Debuggen von C#-Code mit Visual Studio

In diesem Artikel werden die Funktionen des Visual Studio-Debuggers in einer ausführlichen exemplarischen Vorgehensweise vorgestellt. Einen allgemeineren Überblick über die Funktionen des Debuggers finden Sie unter Ein erster Blick auf den Visual Studio-Debugger. Wenn Sie Ihre App debuggen, bedeutet das in der Regel, dass Sie Ihre Anwendung mit dem angefügten Debugger ausführen. Bei dieser Aufgabe bietet der Debugger viele Möglichkeiten zum Ermitteln des Status Ihres Codes während der Ausführung. Sie können Ihren Code schrittweise durchlaufen und die Werte prüfen, die in Variablen gespeichert sind, Sie können die Überwachung von Variablen festlegen, um zu sehen, wenn sich Werte ändern, und Sie können den Ausführungspfad Ihres Codes prüfen und feststellen, ob ein Codezweig ausgeführt wird usw. Wenn Sie in dieser Übung zum ersten Mal versuchen, Code zu debuggen, sollten Sie Debuggen für Einsteiger lesen, bevor Sie diesen Artikel durchgehen.

Auch wenn die Demo-App C# verwendet, beziehen sich die meisten Features auf C++, Visual Basic, F#, Python, JavaScript und andere von Visual Studio unterstützte Programmiersprachen. F# unterstützt „Bearbeiten und fortfahren“ nicht. Das Fenster Auto wird weder von JavaScript noch von F# unterstützt. Die Screenshots wurden in C# erstellt.

In diesem Tutorial werden Sie Folgendes durchführen:

• Starten des Debuggers und Treffen der Breakpoints.
• Erlernen von Befehlen zum Durchlaufen des Codes im Debugger
• Ü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, können Sie es auf der Seite Visual Studio-Downloads kostenlos herunterladen.

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

Zunächst müssen Sie ein Projekt für die .NET Core-Konsolenanwendung erstellen. Der Projekttyp enthält alle nötigen Vorlagendateien, schon bevor Sie mit der Bearbeitung beginnen.

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

2. Klicken Sie im Startfenster auf Neues Projekt erstellen.

3. Geben Sie im Fenster Neues Projekt erstellen im Suchfeld den Begriff Konsole ein. Wählen Sie anschließend in der Liste der Sprachen C# und dann aus der Liste der Plattformen Windows aus.

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

   

   Hinweis

   Wenn die Vorlage Konsolen-App nicht angezeigt wird, können Sie sie über das Fenster Neues Projekt erstellen 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 Workload .NET-Desktopentwicklung aus.

4. Geben Sie anschließend im Fenster Neues Projekt konfigurieren im Feld Projektname den Namen GetStartedDebugging ein. Wählen Sie anschließend Weiter aus.

5. Vergewissern Sie sich, dass im Fenster Zusätzliche Informationen im Dropdownmenü Framework die Option .NET 8.0 ausgewählt ist, und wählen Sie dann Erstellen aus.

Visual Studio öffnet Ihr neues Projekt.

Erstellen der Anwendung

Ersetzen Sie in der Datei Program.cs den gesamten Standardcode durch 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.

In den meisten Fällen verwenden wir hier Tastenkombinationen, weil sie eine schnelle Möglichkeit zum Ausführen von Debuggerbefehlen bieten. Auf gleichwertige Befehle, z. B. Symbolleisten- oder Menübefehle, wird ebenfalls hingewiesen.

1. Um den Debugger zu starten, drücken Sie F5, oder klicken Sie auf der Standardsymbolleiste auf die Schaltfläche Debugziel, oder wählen Sie auf der Debugsymbolleiste die Schaltfläche Debuggen starten aus, oder wählen Sie in der Menüleiste die Optionen Debuggen>Debuggen starten aus.

   

   Über F5 wird die App mit einem an den App-Prozess angefügten Debugger gestartet. Da wir keine besonderen Aktionen zum Untersuchen des Codes durchgeführt haben, wird die App bis zum Abschluss ausgeführt, 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
   

2. Um den Debugger zu beenden, drücken Sie UMSCHALT+F5, oder klicken Sie auf der Debugsymbolleiste auf die Schaltfläche Debuggen beenden, oder wählen Sie in der Menüleiste die Optionen Debuggen>Debuggen beenden aus.

   

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

Festlegen eines Breakpoints und Starten des Debuggers

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

   name += letters[i];

   An der Stelle des Haltepunkts wird ein roter Kreis angezeigt.

   

   Haltepunkte sind ein wesentliches Feature für zuverlässiges Debuggen. Sie können Haltepunkte an den Stellen festlegen, an denen Visual Studio im ausgeführten Code angehalten werden soll. So können Sie einen Blick auf die Werte von Variablen oder das Speicherverhalten werfen oder überprüfen, ob eine Codeverzweigung ausgeführt wird.

2. Um das Debuggen zu starten, drücken Sie F5, oder klicken Sie auf der Standardsymbolleiste auf die Schaltfläche Debugziel, oder wählen Sie auf der Debugsymbolleiste die Schaltfläche Debuggen starten aus, oder wählen Sie in der Menüleiste die Optionen Debuggen>Debuggen starten aus. Die App wird gestartet, und der Debugger wird bis zu der Codezeile ausgeführt, in der Sie den Haltepunkt festgelegt haben.

   

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

   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 wurde, wird sie durch F5 weiter ausgeführt, bis der nächste Haltepunkt erreicht ist.

   Haltepunkte sind eine nützliche Funktion, wenn Ihnen die Codezeile oder der Codeabschnitt bekannt ist, die bzw. den Sie genauer untersuchen möchten. Informationen zu den verschiedenen festlegbaren Typen von Haltepunkten, wie z. B. bedingte Haltepunkte, finden Sie unter Verwenden von Haltepunkten im Visual Studio-Debugger.

Navigieren im Code und Untersuchen 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.

   Hinweis

   Eines der nützlichsten Features des Debuggers ist die Möglichkeit, eine Variable zu überprüfen. Beim Debuggen eines Problems versuchen Sie häufig herauszufinden, ob Variablen die Werte aufweisen, die Sie zu einem bestimmten Zeitpunkt erwarten. Die Anzeige von Datentipps ist eine gute Möglichkeit, dies zu überprüfen.

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

   

3. Zeigen Sie als Nächstes auf die Variable name, um den aktuellen Variablenwert zu sehen: eine leere Zeichenfolge.

4. Um den Debugger zur nächsten Anweisung vorzurücken, drücken Sie F10, oder klicken Sie auf der Debugsymbolleiste auf die Schaltfläche Prozedurschritt, oder wählen Sie in der Menüleiste Debuggen>Prozedurschritt aus. Drücken Sie noch zweimal F10, um hinter den Methodenaufruf SendMessage zu gelangen.

   Durch Drücken von F10 fährt der Debugger fort, ohne Funktionen oder Methoden schrittweise auszuführen. (Der Code wird jedoch ausgeführt.) Auf diese Weise haben wir das Debuggen des Codes in der Methode SendMessage übersprungen, an dem wir derzeit nicht interessiert sind.

5. Um die for-Schleife mehrmals zu durchlaufen, drücken Sie wiederholt F10. 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 Variable ändert sich bei jeder Iteration der for-Schleife, von f in fr in fre usw. 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. Drücken Sie F11, während die Codeausführung in der for-Schleife der Main-Methode angehalten ist, wählen Sie auf der Debugsymbolleiste die Schaltfläche Einzelschritt aus, oder wählen Sie in der Menüleiste Debuggen>Einzelschritt aus, bis Sie den SendMessage-Methodenaufruf erreichen.

   Der Debugger soll in dieser Codezeile angehalten werden:

   SendMessage(name, a[i]);

7. Um die Methode SendMessage schrittweise auszuführen, drücken Sie erneut F11.

   Daraufhin wechselt der gelbe Zeiger in die SendMessage-Methode.

   

   Mithilfe von F11 können Sie den Ausführungsablauf Ihres Codes genauer untersuchen. Drücken Sie F11, um eine Methode aus einem Methodenaufruf schrittweise auszuführen. Standardmäßig überspringt der Debugger die schrittweise Ausführung von Nichtbenutzermethoden. Weitere Informationen zum Debuggen von Nichtbenutzercode finden Sie unter Nur eigenen Code.

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

8. Um die Methode SendMessage zu verlassen, drücken Sie UMSCHALT+F11, oder klicken Sie auf der Debugsymbolleiste auf die Schaltfläche Ausführen bis Rücksprung, oder wählen Sie in der Menüleiste Debuggen>Ausführen bis Rücksprung 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 den verschiedenen Möglichkeiten, durch den Code zu navigieren, finden Sie unter Navigieren durch Code mit dem Visual Studio-Debugger.

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

1. Drücken Sie F5, um wieder 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 den Cursor an der Anweisung Console.WriteLine platzieren und STRG+F10 drücken. 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.

   Daraufhin rückt der Debugger zum Methodenaufruf Console.WriteLine vor.

   Die Verwendung der Schaltfläche Ausführung bis Klick ähnelt dem Festlegen eines temporären Haltepunkts und ist praktisch, um sich in einer geöffneten Datei schnell innerhalb eines sichtbaren Bereichs Ihres App-Codes zu bewegen.

Schnelles Neustarten Ihrer App

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

Durch Neu starten wird der Debugger in einem Schritt beendet und dann neu gestartet. Bei einem Neustart wird der Debugger bis zum ersten Breakpoint ausgeführt, den Sie zuvor in der for-Schleife festgelegt haben, und dann angehalten.

Untersuchen von Variablen über die Fenster „Auto“ und „Lokal“

In den Fenstern Auto und Lokal werden Variablenwerte während des Debuggens angezeigt. Die Fenster sind nur während einer Debugsitzung verfügbar. Im Fenster Auto werden Variablen angezeigt, die in der aktuellen Zeile, in der sich der Debugger befindet, und in der vorangehenden Zeile verwendet werden. Im Fenster Lokale Variablen werden Variablen angezeigt, die im lokalen Gültigkeitsbereich definiert sind, der in der Regel aus der aktuellen Funktion oder Methode besteht.

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 Fenster Lokal geschlossen ist, drücken Sie STRG+D, L, oder wählen Sie Debuggen>Fenster>Lokal aus.

3. Erweitern Sie im Fenster Lokal die Variable letters, um alle zugehörigen 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“.

Festlegen von Überwachung

Sie können Variablen oder Ausdrücke angeben, die Sie beim schrittweisen Ausführen des Codes im Auge behalten möchten, indem Sie sie dem Überwachungsfenster 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 Fenster Überwachung immer die Variablen an, die Sie überwachen. Variablen, die außerhalb des gültigen Bereichs liegen, werden als nicht verfügbar angezeigt.

Weitere Informationen zum Fenster Überwachen finden Sie unter Überwachen von Variablen mit Überwachungsfenstern.

Überprüfen der Aufrufliste

Anhand der Aufrufliste können Sie den Ausführungsablauf Ihrer App nachvollziehen, da sie die Reihenfolge zeigt, 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.

   In der obersten Zeile des Fensters Aufrufliste wird die aktuelle Funktion angezeigt, in diesem Fall die Methode SendMessage. In der zweiten Zeile wird angezeigt, dass die Methode SendMessage über die Methode Main aufgerufen wurde.

   

   Hinweis

   Das Fenster Aufrufliste ist mit der Debugperspektive in einigen IDEs wie Eclipse vergleichbar.

   Sie können im Fenster Aufrufliste auf eine Codezeile doppelklicken, um den zugehörigen Quellcode anzuzeigen. Dadurch wird der aktuelle Bereich geändert, der vom Debugger untersucht wird. Durch diese Aktion wird der Debugger nicht weiter ausgeführt.

   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.

Ändern des Ausführungsablaufs

Sie können den Ausführungszeiger verschieben, um den Ablauf Ihrer App während des Debuggens zu ändern.

1. Während der Debugger beim Methodenaufruf SendMessage in der for-Schleife angehalten ist, drücken Sie dreimal F11, um die Methode SendMessage schrittweise auszuführen und nach der Ausführung hinter die Methode Console.WriteLine zu gelangen.

   Der Debugger wird nun an der letzten rechten geschweiften Klammer der Methode SendMessage angehalten.

2. Verwenden Sie die Maus, um den gelben Pfeil oder den Ausführungszeiger (am linken Rand) um eine Zeile nach oben zu ziehen.

   Der Debugger befindet sich jetzt wieder in der Anweisung Console.WriteLine.

3. Drücken Sie F11.

   Der Debugger führt die Methode Console.WriteLine erneut aus, und in der Ausgabe des Konsolenfensters wird eine doppelte Zeile angezeigt.

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

Durch Ändern des Ausführungsablaufs können Sie Aktionen ausführen wie das Testen verschiedener Pfade für die Codeausführung oder das erneute Ausführen von Code ohne Neustarten des Debuggers.

Warnung

Verwenden Sie dieses Feature mit Vorsicht. In der QuickInfo des Ausführungszeigers wird eine Warnung vor möglichen unbeabsichtigten Folgen angezeigt. Möglicherweise werden Ihnen auch andere Warnungen angezeigt. Durch das Verschieben des Ausführungszeigers können Sie Ihre Anwendung nicht auf einen früheren Zustand zurücksetzen.

Weitere Informationen zum Ändern des Ausführungsablaufs finden Sie unter Bewegen des Zeigers zum Ändern des Ausführungsablaufs.

Damit haben Sie das Tutorial erfolgreich abgeschlossen.

Nächste Schritte

In diesem Tutorial haben Sie gelernt, wie Sie den Debugger starten, Code schrittweise durchlaufen und Variablen untersuchen. Über die Links zu weiteren Informationen können Sie sich einen allgemeinen Überblick über die Debuggerfeatures verschaffen.

Erster Einblick in den Debugger