Schnellstart: Debuggen mit C# oder Visual Basic mithilfe des Visual Studio-Debuggers

Der Visual Studio-Debugger bietet viele leistungsstarke Features, mit denen Sie Ihre Apps debuggen können. Dieser Artikel bietet eine schnelle Möglichkeit, einige der grundlegenden Features kennenzulernen.

Erstellen eines neuen Projekts

1. Öffnen Sie Visual Studio, und erstellen Sie ein neues Projekt.

   Wenn das Startfenster nicht geöffnet ist, wählen Sie Datei>Startfensteraus. Wählen Sie im Startfenster Neues Projekt erstellen aus.

   Geben Sie im Fenster Neues Projekt erstellen im Suchfeld 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 Konsolen-App-Vorlage für .NET Core und dann "Weiter" aus.

   Wählen Sie entweder das empfohlene Zielframework oder .NET 10 aus, und wählen Sie dann "Erstellen" aus.

   Wenn die Konsolen-App-Projektvorlage für .NET Core nicht angezeigt wird, wechseln Sie zu Tools>abrufen Tools und Features..., wodurch das Visual Studio-Installationsprogramm geöffnet wird. Wählen Sie die Workload Plattformübergreifende .NET Core-Entwicklung aus, und klicken Sie dann auf Anpassen.

   Visual Studio erstellt das Projekt.

2. Ersetzen Sie in Program.cs oder Module1.vb den folgenden Code:

   C#

   class Program
   {
       static void Main(string[] args)
       {
       }
   }
   

   VB

   Module Module1
       Sub Main()
       End Sub
   End Module
   

   mit diesem Code:

   C#

   class Program
   {
       private static void doWork()
       {
           LinkedList<int> c1 = new LinkedList<int>();
   
           c1.AddLast(10);
           c1.AddLast(20);
   
           LinkedList<int> c2 = new LinkedList<int>(c1);
           int i = c2.First.Value;
           int j = c2.First.Value;
           Console.Write("The first element is ");
           Console.Write(i);
           Console.Write("\n");
           Console.Write("The second element is ");
           Console.Write(j);
           Console.Write("\n");
   
       }
   
       static int Main()
       {
           // using namespace std;
           doWork();
           return 0;
   
       }
   }
   

   VB

   Imports System.Collections.Generic
   
   Namespace MyDbgApp
       Class Program
           Private Shared Sub doWork()
               Dim c1 As New LinkedList(Of Integer)()
   
               c1.AddLast(10)
               c1.AddLast(20)
   
               Dim c2 As New LinkedList(Of Integer)(c1)
               Dim i As Integer = c2.First.Value
               Dim j As Integer = c2.First.Value
               Console.Write("The first element is ")
               Console.Write(i)
               Console.Write(vbLf)
               Console.Write("The second element is ")
               Console.Write(j)
               Console.Write(vbLf)
   
           End Sub
   
           Public Shared Function Main() As Integer
               ' using namespace std;
               doWork()
               Return 0
   
           End Function
       End Class
   End Namespace
   

   Hinweis

   Stellen Sie in Visual Basic sicher, dass das Startobjekt auf (Sub Main) festgelegt > ist.

Haltepunkt festlegen

Ein Haltepunkt ist eine Markierung, die angibt, 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 eine Verzweigung des Codes ausgeführt wird. Dies ist das grundlegendste Feature beim Debuggen.

1. Um den Haltepunkt festzulegen, klicken Sie in der Seitenleiste links vom doWork Funktionsaufruf (oder wählen Sie die Codezeile aus und drücken Sie F9).

   

2. Drücken Sie nun F5 (oder wählen Sie "Debugging starten" > aus).

   

   Der Debugger hält an dem Breakpoint an, den Sie festlegen. Ein gelber Pfeil identifiziert die Anweisung, in der der Debugger und die App-Ausführung angehalten wird. Die Zeile mit dem doWork Funktionsaufruf wurde noch nicht ausgeführt.

   Tipp

   Wenn Sie einen Haltepunkt in einer Schleife oder Rekursion haben oder viele Haltepunkte haben, die Sie häufig durchlaufen, verwenden Sie einen bedingten Haltepunkt , um sicherzustellen, dass Ihr Code NUR angehalten wird, wenn bestimmte Bedingungen erfüllt sind. Ein bedingter Haltepunkt kann Zeit sparen und es kann auch das Debuggen von Problemen erleichtern, die schwer zu reproduzieren sind.

Im Code navigieren

Es gibt verschiedene Befehle, die den Debugger anweisen, den Vorgang fortzusetzen. Wir zeigen einen nützlichen Codenavigationsbefehl an, der ab Visual Studio 2017 verfügbar ist.

Während der Code am Haltepunkt angehalten wird, bewegen Sie den Mauszeiger über die Anweisung c1.AddLast(20), bis die grüne Schaltfläche Run to Click angezeigt wird, und drücken Sie dann die Schaltfläche Run to Click.

Die App setzt die Ausführung fort, ruft doWork auf und hält an der Codezeile an, auf der Sie auf die Schaltfläche geklickt haben.

Allgemeine Tastaturbefehle, die zum Schrittweisen Durchlaufen von Code verwendet werden, umfassen F10 und F11. Ausführlichere Anweisungen finden Sie unter "Erster Blick auf den Debugger".

Überprüfen von Variablen in einem Datentipp

1. Zeigen Sie in der aktuellen Zeile des Codes (gekennzeichnet durch den gelben Ausführungspunkt) mit der Maus auf das Objekt c1, um einen Datentipp anzuzeigen.

   

   Der Datentipp zeigt Ihnen den aktuellen Wert der c1 Variablen an und ermöglicht es Ihnen, deren Eigenschaften zu überprüfen. Wenn beim Debuggen ein Wert angezeigt wird, den Sie nicht erwarten, haben Sie wahrscheinlich einen Fehler in den vorherigen oder aufrufenden Codezeilen.

2. Erweitern Sie den Datentipp, um die aktuellen Eigenschaftswerte des c1 Objekts anzuzeigen.

3. Wenn Sie den Datentipp anheften möchten, damit Sie den Wert von c1 weiterhin sehen können, während Sie den Code ausführen, wählen Sie das kleine Pinsymbol aus. (Sie können den angehefteten Datentipp an eine bequeme Position verschieben.)

Bearbeiten von Code und Fortsetzen des Debuggens

Wenn Sie eine Änderung identifizieren, die Sie im Code während einer Debugsitzung testen möchten, können Sie dies auch tun.

1. Wählen Sie die zweite Instanz von c2.First.Value und ändern Sie c2.First.Value zu c2.Last.Value.

2. Drücken Sie F10 (oder Debug > Step Over) ein paar Mal, um den Debugger weiterzuführen und den bearbeiteten Code auszuführen.

   

   F10 führt den Debugger jeweils um eine Anweisung weiter, setzt jedoch Funktionsaufrufe fort, anstatt in sie hineinzugehen (der Code, den Sie überspringen, wird weiterhin ausgeführt).

Weitere Informationen zur Verwendung von Bearbeiten und Fortsetzen sowie zu Featurebeschränkungen finden Sie unter Bearbeiten und Fortsetzen.

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