Tutorial: Debuggen von C#-Code mit Visual Studio

  • Artikel

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.

Sie müssen Visual Studio 2019 und die Workload Plattformübergreifende .NET Core-Entwicklung installiert haben.

Wenn Sie Visual Studio noch nicht installiert haben, können Sie es auf der Seite Visual Studio-Downloads kostenlos herunterladen.

Wenn Sie die Workload installieren müssen, Visual Studio aber bereits besitzen, navigieren Sie zu Tools>Tools und Features abrufen… . Dadurch wird der Visual Studio-Installer geöffnet. Der Visual Studio-Installer wird gestartet. Wählen Sie die Workload Plattformübergreifende .NET Core-Entwicklung aus, und klicken Sie dann auf Anpassen.

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.

  1. 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 für .NET Core und dann Weiter aus.

    Screenshot of the C# template for the Console App.

    Hinweis

    Wenn die Vorlage Konsolen-App nicht angezeigt wird, können Sie sie im 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 anschließend im Visual Studio-Installer die Workload Plattformübergreifende .NET Core-Entwicklung aus.

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

  3. Wählen Sie das empfohlene Zielframework (.NET 8.0 oder Long-Term Support) und dann Erstellen aus.

  1. 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.

    Screenshot of the 'Console Application' template in the 'Create a new project' window of Visual Studio 2022.

    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.

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

  3. 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.

  1. Drücken Sie die Taste F5 (Debuggen > Debuggen starten), oder klicken Sie in der Symbolleiste „Debuggen“ auf die Schaltfläche Debuggen startenImage of the Start Debugging button..

    Durch Drücken der Taste F5 wird die App mit dem an den App-Prozess angefügten Debugger gestartet. Bisher haben Sie jedoch nichts weiter gemacht, um den Code zu untersuchen. Die App wird lediglich geladen, und Ihnen wird diese Konsolenausgabe 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 Tutorial werfen wir einen genaueren Blick auf diese App mit dem Debugger und lernen die Funktionen des Debuggers kennen.

  2. Beenden Sie den Debugger, indem Sie die rote Stoppschaltfläche drücken (UMSCHALT + F5). Image of the Stop Debugging button.

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

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.

    Screenshot of the Debug Target button in the Standard toolbar of Visual Studio 2022.

    Ü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.

    Screenshot of the Stop debugging button in the Debug toolbar of Visual Studio 2022.

  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, an der Sie den Breakpoint gesetzt haben, wird ein roter Kreis (Image of a breakpoint.) angezeigt.

    Haltepunkte sind ein einfaches und wichtiges Feature zum zuverlässigen Debuggen. Ein Haltepunkt gibt an, wo 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 Verzweigung im Code ausgeführt wird.

  2. Drücken Sie F5 oder die Schaltfläche Debuggen starten. Screenshot of the Start Debugging button. Die App wird gestartet, und der Debugger wird bis zu der Codezeile ausgeführt, in der Sie den Breakpoint festgelegt haben.

    Set and hit a breakpoint

    Der gelbe Pfeil stellt die Anweisung dar, an der der Debugger angehalten hat. An der gleichen Stelle wird auch die Ausführung der App unterbrochen (diese Anweisung wurde noch nicht ausgeführt).

    Wenn die App noch nicht ausgeführt wird, kann der Debugger durch Drücken der Taste F5 gestartet werden und hält am ersten Breakpoint an. Andernfalls wird durch Drücken der Taste F5 die Ausführung der App bis zum nächsten Haltepunkt fortgesetzt.

    Breakpoints 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 verfügbaren Typen von Haltepunkten, wie z. B. bedingte Haltepunkte, finden Sie unter Verwenden von Haltepunkten im Visual Studio-Debugger.

  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.

    Screenshot of a breakpoint in Visual Studio 2022.

    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.

    Screenshot showing a breakpoint in the code editor of Visual Studio 2022, with code execution paused at the breakpoint.

    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.

In der Regel verwenden wir an dieser Stelle Tastenkombinationen, da auf diese Weise eine schnelle Ausführung Ihrer App im Debugger möglich ist (entsprechende Befehle, wie z.B. Menübefehle, werden in Klammern angezeigt).

  1. Während die Codeausführung bei der name += letters[i]-Anweisung angehalten ist, zeigen Sie auf die letters-Variable. Dadurch wird der Standardwert der Variablen angezeigt, bei dem es sich um den Wert des ersten Elements im Array handelt: char[10].

    Funktionen, mit denen Sie Variablen untersuchen können, zählen zu den nützlichsten Funktionen des Debuggers. Es gibt verschiedene Möglichkeiten, Variablen zu untersuchen. Beim Debuggen eines Problems wird häufig versucht herauszufinden, ob Variablen die Werte speichern, die diese zu einem bestimmten Zeitpunkt aufweisen sollen.

  2. Erweitern Sie die Variable letters, damit ihre Eigenschaften angezeigt werden. Dazu zählen auch alle in der Variable enthaltenen Elemente.

    Screenshot of the debugger paused at the 'name+= letters[I]' statement.

  3. Zeigen Sie als Nächstes auf die name-Variable. Daraufhin wird Ihnen der aktuelle Variablenwert angezeigt: eine leere Zeichenfolge.

  4. Drücken Sie zweimal F10, oder wählen Sie Debuggen > Prozedurschritt aus, um mit dem Aufruf der SendMessage-Methode fortzufahren, und drücken Sie dann F10 ein weiteres Mal.

    Durch Drücken der Taste F10 fährt der Debugger mit der nächsten Anweisung in Ihrem App-Code fort, ohne dass Funktionen oder Methoden schrittweise ausgeführt werden (der Code wird weiterhin ausgeführt). Durch Drücken von F10 im SendMessage-Methodenaufruf wurde der Implementierungscode für SendMessage übersprungen (der für uns gerade möglicherweise nicht von Interesse ist).

  5. Drücken Sie mehrmals auf F10 (oder Debuggen>Prozedurschritt), um mehrmals die for-Schleife zu durchlaufen. Dabei pausiert der Debugger jedes Mal am Breakpoint, sodass Sie auf die name-Variable zeigen und ihren Wert überprüfen können.

    An animated screenshot of the Visual Studio Debugger showing the effect of pressing F10 to

    Der Wert der Variable ändert sich bei jeder Iteration der for-Schleife, von f in fr in fre usw. Damit der Debugger die Schleife in diesem Szenario schneller durchläuft, können Sie stattdessen F5 drücken oder Debuggen>Fortsetzen auswählen, um zum nächsten Breakpoint anstatt zur nächsten Anweisung zu springen.

    Beim Debuggen sollen Eigenschaftswerte von Variablen schnell überprüft werden können, um herauszufinden, ob sie die vorgesehenen Werte speichern. Die Datentipps sind eine gute Möglichkeit dafür.

  6. Drücken Sie F11, oder wählen Sie Debuggen > Einzelschritt aus, während die Codeausführung noch in der for-Schleife der Main-Methode pausiert ist, bis Sie beim SendMessage-Methodenaufruf angelangt sind.

    Sie sollten sich in der folgenden Codezeile befinden:

    SendMessage(name, a[i]);

  7. Drücken Sie noch mal F11, um die SendMessage-Methode schrittweise auszuführen.

    Daraufhin wechselt der gelbe Zeiger in die SendMessage-Methode.

    Screenshot of the execution pointer at the SendMessage method.

    Durch Drücken der Taste F11 wird der Befehl Einzelschritt ausgeführt, und die App wird Anweisung für Anweisung ausgeführt. F11 ist eine gute Möglichkeit, den Ausführungsablauf sehr detailliert zu überprüfen. Standardmäßig überspringt der Debugger Nichtbenutzercode (weitere Einzelheiten hierzu finden Sie unter Nur eigenen Code).

    Nehmen Sie an, dass Sie die Untersuchung der SendMessage-Methode abgeschlossen haben und die Methode beenden möchten, aber nicht den Debugger. Dies ist mit dem Befehl Ausführen bis Rücksprung möglich.

  8. Drücken Sie UMSCHALT + F11 (oder klicken Sie auf Debuggen > Ausführen bis Rücksprung).

    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.

    Der Debugger befindet sich nun wieder in der for-Schleife der Main-Methode und wurde beim Methodenaufruf von 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.

  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.

    Screenshot of a debugger data tip in Visual Studio 2022 that shows the element values for the 'letters' array variable.

  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.

    Screenshot of a debugger data tip in Visual Studio 2022 that shows the string value for the 'name' variable.

    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.

    Screenshot showing the execution pointer of the debugger within the 'SendMessage' method.

    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.

  1. Drücken Sie F5, um wieder zum Haltepunkt vorzurücken.

  2. Scrollen Sie im Code-Editor nach unten, und zeigen Sie mit dem Cursor so lange auf die Console.WriteLine-Methode in der SendMessage-Methode, bis die grüne Schaltfläche Ausführung bis Klick (Image of the Run to Click button.) angezeigt wird. Die QuickInfo für die Schaltfläche zeigt „Ausführung bis hier“ an.

    Screenshot of the Run to Click button.

    Hinweis

    Die Schaltfläche Ausführung bis Klick ist neu in Visual Studio 2017. Wenn Ihnen die Schaltfläche mit dem grünen Pfeil nicht angezeigt wird, verwenden Sie in diesem Beispiel stattdessen die Taste F11, damit der Debugger an der richtigen Stelle fortfährt.

  3. Wählen Sie die Schaltfläche Ausführung bis Klick aus. Image of the Run to Click button.

    Daraufhin wechselt der Debugger zur Console.WriteLine-Methode.

    Die Verwendung dieser Schaltfläche ist mit dem Festlegen eines temporären Breakpoints vergleichbar. Ausführung bis Klick ist praktisch, um schnell durch einen sichtbaren Bereich des App-Codes zu navigieren. Sie können in eine beliebige geöffnete Datei klicken.

  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.

    Screenshot showing the Run to Click button in Visual Studio 2022.

  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

Wählen Sie auf der Symbolleiste „Debuggen“ die Schaltfläche Neu starten (Image of the Restart App button.) aus (STRG + UMSCHALT + FF5).

Durch das Klicken auf Neu starten sparen Sie im Vergleich zum Beenden der App und dem erneuten Starten des Debuggers Zeit. Der Debugger hält am ersten Breakpoint an, der bei der Codeausführung erreicht wird.

Der Debugger hält wieder an dem von Ihnen zuvor in der for-Schleife festgelegten Haltepunkt an.

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.

Screenshot of the Restart button in the Debug toolbar of Visual Studio 2022.

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“

  1. Schauen Sie sich das Fenster Auto unten im Code-Editor an.

    Falls dieses geschlossen ist, öffnen Sie es, solange der Debugger angehalten ist. Wählen Sie hierzu Debuggen>Fenster>Auto aus.

    Im Fenster Auto werden Ihnen Variablen und der zugehörige aktuelle Wert angezeigt. Im Auto-Fenster werden alle Variablen angezeigt, die auf der aktuellen Zeile oder der vorangehenden Zeile verwendet werden (lesen Sie dazu die Dokumentation für sprachspezifisches Verhalten).

  2. Schauen Sie sich als Nächstes das Fenster Lokal auf einer Registerkarte neben dem Fenster Auto an.

  3. Klappen Sie die letters-Variable auf, um die darin enthaltenen Elemente anzuzeigen.

    Screenshot of the Locals Window in Visual Studio.

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

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.

    Screenshot of the Locals window in Visual Studio 2022, with the 'letters' array variable expanded.

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

Festlegen von Überwachung

Klicken Sie im Hauptfenster des Code-Editors mit der rechten Maustaste auf die name-Variable, und wählen Sie Überwachung hinzufügen aus.

Das Fenster Überwachung wird unten im Code-Editor geöffnet. Sie können über das Fenster Überwachung eine Variable (oder einen Ausdruck) angeben, die Sie im Auge behalten möchten.

Nun haben Sie festgelegt, dass die name-Variable überwacht werden soll, und Sie können seine Wertänderung sehen, wenn Sie durch den Debugger navigieren. Im Gegensatz zu den anderen Variablenfenstern werden im Fenster Überwachung immer die Variablen angezeigt, die von Ihnen überwacht werden (wenn sie außerhalb des gültigen Bereichs liegen, sind sie ausgegraut).

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

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

    Falls dieses geschlossen ist, öffnen Sie es, solange der Debugger angehalten ist. Wählen Sie hierzu Debuggen>Fenster>Aufrufliste aus.

  2. Drücken Sie einige Male die Taste F11, bis der Debugger bei der Methode SendMessage anhält. Schauen Sie sich das Fenster Aufrufliste an.

    Screenshot of the Call Stack window in Visual Studio.

    Im Fenster Aufrufliste wird die Reihenfolge angezeigt, in der Methoden und Funktionen aufgerufen werden. In der obersten Zeile wird die aktuelle Funktion (in dieser App die SendMessage-Methode) angezeigt. In der zweiten Zeile wird angezeigt, dass SendMessage über die Main-Methode aufgerufen wurde usw.

    Hinweis

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

    Die Aufrufliste bietet eine nützliche Möglichkeit zum Untersuchen und Verstehen des Ausführungsablaufs einer App.

    Sie können auf eine Codezeile doppelklicken, um den Quellcode anzuzeigen. Dadurch wird auch 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. So können Sie beispielsweise Haltepunkte in bestimmte Funktionen einfügen, den Debugger über Ausführen bis Cursor weiter ausführen und Quellcode untersuchen. Weitere Informationen finden Sie unter View the call stack and use the Call Stack window in the debugger Examine the Call Stack (Vorgehensweise: Untersuchen 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.

    Screenshot of the Call Stack window in Visual Studio 2022.

    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

  1. Drücken Sie zweimal auf 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ührungszeiger (am linken Rand) auszuwählen, und ziehen Sie den Mauszeiger um eine Zeile nach oben in die Console.WriteLine-Anweisung.

  3. Drücken Sie die Taste F11.

    Der Debugger führt die Console.WriteLine-Methode erneut aus. Diese Aktion wird Ihnen in der Ausgabe im Konsolenfenster angezeigt.

    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

    Bei dieser Funktion müssen Sie häufig vorsichtig vorgehen. Sie werden durch eine Warnung in der QuickInfo auf Probleme aufmerksam gemacht. Möglicherweise werden Ihnen auch andere Warnungen angezeigt. Durch das Verschieben des Zeigers können Sie Ihre Anwendung nicht auf einen früheren App-Status zurücksetzen.

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

    Damit haben Sie das Tutorial erfolgreich abgeschlossen.

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