Lernprogramm: Debuggen von C# und C++ in derselben Debugsitzung

Mit Visual Studio können Sie mehrere Debuggertypen in einer Debugsitzung aktivieren, die als Debugging im gemischten Modus bezeichnet wird. In diesem Lernprogramm lernen Sie, verwalteten und systemeigenen Code in einer einzigen Debugsitzung zu debuggen.

In diesem Tutorial wird veranschaulicht, wie Sie nativen Code aus einer verwalteten App debuggen, Sie können jedoch ebenfalls verwalteten Code aus einer nativen App debuggen. Der Debugger unterstützt außerdem weitere Typen des Debuggens im gemischten Modus wie das Debuggen von Python-Code und von nativem Code und das Verwenden des Skriptdebuggers in App-Typen wie ASP.NET.

In diesem Tutorial werden Sie:

• Erstellen einer einfachen nativen DLL
• Erstellen Einer einfachen .NET Core- oder .NET Framework-App zum Aufrufen der DLL
• Konfigurieren des Debuggings im gemischten Modus
• Starten des Debuggers
• Erreichen eines Haltepunkts in der verwalteten App
• Schritt in den systemeigenen Code

Voraussetzungen

Sie müssen Visual Studio mit den folgenden Workloads installiert haben:

• Desktopentwicklung mit C++-
• .NET-Desktopentwicklung

Wenn Sie nicht über Visual Studio verfügen, wechseln Sie zur Visual Studio-Downloads Seite, um es kostenlos zu installieren.

Wenn Sie Visual Studio installiert haben, aber nicht über die benötigten Workloads verfügen, wählen Sie Visual Studio Installer- im linken Bereich des Dialogfelds "Visual Studio Neues Projekt öffnen" aus. Wählen Sie im Visual Studio-Installer die benötigten Workloads und anschließend Anpassen aus.

Erstellen einer einfachen nativen DLL

So erstellen Sie die Dateien für das DLL-Projekt:

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

   Drücken Sie ESC-, um das Startfenster zu schließen. Geben Sie STRG+Q- ein, um das Suchfeld zu öffnen, geben Sie Leeren Projektein, wählen Sie Vorlagenaus, und wählen Sie dann Leeren Projekt für C++ aus. Wählen Sie im angezeigten Dialogfeld Erstellen aus. Geben Sie anschließend einen Namen wie Mixed_Mode_Debugging ein, und klicken Sie auf Erstellen.

   Wenn die Projektvorlage "Leeres Projekt" nicht angezeigt wird, wechseln Sie zu Tools>Abrufen von Tools und Features..., wodurch das Visual Studio-Installationsprogramm geöffnet wird. Das Visual Studio-Installationsprogramm wird gestartet. Wählen Sie die Workload Desktopentwicklung mit C++ und anschließend Ändern aus.

   Visual Studio erstellt das Projekt.

2. Wählen Sie im Projektmappen-Explorer die Option Quelldateien und anschließend Projekt>Neues Element hinzufügen aus. Klicken Sie alternativ mit der rechten Maustaste auf Quelldateien, und wählen Sie Hinzufügen>Neues Element aus.

   Wenn nicht alle Elementvorlagen angezeigt werden, wählen Sie Alle Vorlagen anzeigenaus.

3. Wählen Sie im Dialogfeld Neues ElementC++-Datei (.cpp)aus. Geben Sie im Feld NameMixed_Mode.cpp ein, und wählen Sie dann Hinzufügen aus.

   Visual Studio fügt im Projektmappen-Explorer eine neue C++-Datei hinzu.

4. Kopieren Sie den folgenden Code in Mixed_Mode.cpp:

   #include "Mixed_Mode.h"
   

5. Wählen Sie im Projektmappen-Explorer die Option Headerdateien und anschließend Projekt>Neues Element hinzufügen aus. Klicken Sie alternativ auf Headerdateien, und wählen Sie Hinzufügen>Neues Element aus.

   Wenn nicht alle Elementvorlagen angezeigt werden, wählen Sie Alle Vorlagen anzeigenaus.

6. Wählen Sie im Dialogfeld Neues Element die Option Headerdatei (.h) aus. Geben Sie im Feld NameMixed_Mode.h ein, und klicken Sie dann auf Hinzufügen.

   Visual Studio fügt die neue Headerdatei dem Lösungs-Explorerhinzu.

7. Kopieren Sie den folgenden Code in Mixed_Mode.h:

   #ifndef MIXED_MODE_MULTIPLY_HPP
   #define MIXED_MODE_MULTIPLY_HPP
   
   extern "C"
   {
     __declspec(dllexport) int __stdcall mixed_mode_multiply(int a, int b) {
       return a * b;
     }
   }
   #endif
   

8. Klicken Sie auf Datei>Alle speichern, oder drücken Sie STRG+UMSCHALT+S, um die Datei zu speichern.

So konfigurieren und erstellen Sie das DLL-Projekt:

1. Wählen Sie auf der Visual Studio-Symbolleiste die Konfiguration Debuggen und entweder x86 oder x64 für die Plattform aus. Wenn Ihre aufrufende App .NET Core ist, die immer im 64-Bit-Modus ausgeführt wird, wählen Sie x64- als Plattform aus.

2. Wählen Sie im Projektmappen-Explorer den Projektknoten Mixed_Mode_Debugging aus, und klicken Sie auf das Eigenschaftensymbol. Klicken Sie alternativ auf den Projektknoten und dann auf Eigenschaften.

3. Stellen Sie oben im Bereich Eigenschaften sicher, dass die -Konfigurations- auf Active(Debug)- festgelegt ist, und die Platform- entspricht dem, was Sie in der Symbolleiste festlegen: x64-oder Win32- für x86-Plattform.

   Wichtig

   Wenn Sie von x86- zur x64- oder umgekehrt wechseln, müssen Sie die Eigenschaften für die neue Plattform neu konfigurieren.

4. Wählen Sie links unter KonfigurationseigenschaftenLinker>Erweitert aus, und wählen Sie in der Dropdownliste neben Kein EinstiegspunktNein aus. Wenn Sie es in Neinändern müssen, wählen Sie Anwenden.

5. Wählen Sie unter Konfigurationseigenschaftenallgemeineaus, und wählen Sie in der Dropdownliste neben Konfigurationstypdynamische Bibliothek (.dll)aus. Klicken Sie auf Anwenden und dann auf OK.

   

6. Wählen Sie im Projektmappen-Explorer das Projekt aus, und wählen Sie dann Erstellen>Projektmappe erstellen aus. Drücken Sie anschließend F7, oder klicken Sie mit der rechten Maustaste auf das Projekt, und wählen Sie Erstellen aus.

   Das Projekt sollte ohne Fehler erstellt werden.

Erstellen einer einfachen verwalteten App zum Aufrufen der DLL

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

   Drücken Sie ESC-, um das Startfenster zu schließen. Geben Sie STRG+Q- ein, um das Suchfeld zu öffnen, geben Sie Konsolen-ein, wählen Sie Vorlagenaus, und wählen Sie dann Konsolen-App für .NET Core oder Konsolen-App (.NET Framework) für C# aus. Wählen Sie im daraufhin angezeigten Dialogfeld Weiteraus.

   Geben Sie dann einen Namen wie Mixed_Mode_Calling_App ein, und klicken Sie auf Next oder Create, je nachdem, welche Option verfügbar ist.

   Wählen Sie für .NET Core entweder das empfohlene Zielframework oder .NET 8 aus, und wählen Sie dann Erstellen aus.

   Wenn die richtige Projektvorlage nicht angezeigt wird, wechseln Sie zu Tools>Abrufen von Tools und Features..., wodurch das Visual Studio-Installationsprogramm geöffnet wird. Wählen Sie die richtige .NET-Workload aus, wie in den Voraussetzungen beschrieben, und wählen Sie dann Ändern aus.

   Anmerkung

   Sie können das neue verwaltete Projekt auch zu Ihrer vorhandenen C++-Lösung hinzufügen. Wir erstellen das Projekt in einer neuen Lösung, damit die Debuggingaufgabe im gemischten Modus schwieriger wird.

   Visual Studio erstellt das leere Projekt und zeigt es im Projektmappen-Exploreran.

2. Ersetzen Sie den gesamten Code in Program.cs durch den folgenden Code:

   using System;
   using System.Runtime.InteropServices;
   
   namespace Mixed_Mode_Calling_App
   {
       public class Program
       {
           // Replace the file path shown here with the
           // file path on your computer. For .NET Core, the typical (default) path
           // for a 64-bit DLL might look like this:
           // C:\Users\username\source\repos\Mixed_Mode_Debugging\x64\Debug\Mixed_Mode_Debugging.dll
           // Here, we show a typical path for a DLL targeting the **x86** option.
           [DllImport(@"C:\Users\username\source\repos\Mixed_Mode_Debugging\Debug\Mixed_Mode_Debugging.dll", EntryPoint =
           "mixed_mode_multiply", CallingConvention = CallingConvention.StdCall)]
           public static extern int Multiply(int x, int y);
           public static void Main(string[] args)
           {
               int result = Multiply(7, 7);
               Console.WriteLine("The answer is {0}", result);
               Console.ReadKey();
           }
       }
   }
   

3. Ersetzen Sie im neuen Code den Dateipfad in [DllImport] durch Ihren Dateipfad zu dem soeben erstellten Mixed_Mode_Debugging.dll. Hinweise finden Sie im Codekommentar. Achten Sie darauf, dass Sie den Platzhalter username entsprechend ersetzen.

4. Wählen Sie Datei>Speichern Program.cs oder drücken Sie STRG+S, um die Datei zu speichern.

Konfigurieren des Debuggings im gemischten Modus

1. Wählen Sie im Solution Explorerden Mixed_Mode_Calling_App Projektknoten aus, und wählen Sie das Symbol Eigenschaften aus, oder klicken Sie mit der rechten Maustaste auf den Projektknoten, und wählen Sie Eigenschaftenaus.

2. Aktivieren des systemeigenen Codedebuggings in den Eigenschaften.

   .NET-Code

   Wählen Sie im linken Bereich Debuggen aus. Wählen Sie Öffnen der Benutzeroberfläche von Debugstartprofilen aus, und aktivieren Sie dann das Kontrollkästchen Debuggen von nativem Code aktivieren, und schließen Sie anschließend die Eigenschaftenseite, um die Änderungen zu speichern.

   

   .NET Framework-Code

   Wählen Sie im linken Menü Debugaus. Wählen Sie dann im Abschnitt Debuggermodule die Eigenschaft Aktivieren des systemeigenen Codedebuggings und schließen Sie dann die Eigenschaftenseite, um die Änderungen zu speichern.

3. Wenn Sie auf eine x64-DLL aus einer .NET Framework-App abzielen, ändern Sie das Plattformziel von Any CPU in x64. Dazu müssen Sie möglicherweise aus der Dropdownliste „Projektmappenplattform“ der Symbolleiste „Debuggen“ die Option Configuration Manager auswählen. Wenn Sie dann nicht direkt zu x64 wechseln können, erstellen Sie eine Neue Konfiguration, die auf x64 ausgerichtet ist.

Einen Haltepunkt setzen und das Debuggen starten

1. Öffnen Sie im C#-Projekt Program.cs. Legen Sie einen Breakpoint in der folgenden Codezeile fest, indem Sie auf den linken Rand klicken, die Zeile auswählen und dann F9 drücken. Alternativ können Sie mit der rechten Maustaste auf die Codezeile klicken und Breakpoint>Breakpoint einfügen auswählen.

   int result = Multiply(7, 7);
   

   Am linken Rand wird ein roter Kreis angezeigt, in dem Sie den Haltepunkt festlegen.

2. Drücken Sie F5-, wählen Sie den grünen Pfeil in der Visual Studio-Symbolleiste aus, oder wählen Sie Debuggen>Debuggen starten aus, um mit dem Debuggen zu beginnen.

   Der Debugger hält an dem von Ihnen festgelegten Haltepunkt an. Ein gelber Pfeil gibt an, wo der Debugger derzeit angehalten ist.

Einzelschritt und Ausführen bis Rücksprung in nativem Code

1. Wenn das Debuggen in der verwalteten App angehalten ist, drücken Sie F11, oder klicken Sie auf Debuggen>Einzelschritt.

   Die native Headerdatei Mixed_Mode.h wird geöffnet, und der gelbe Pfeil gibt die Stelle an, an der der Debugger sich gerade befindet.

   

2. Jetzt können Sie Breakpoints festlegen und erreichen und sich Variablen im nativen oder verwalteten Code ansehen.

   • Zeigen Sie mit der Maus auf Variablen im Quellcode, um deren Werte anzuzeigen.

   • Sehen Sie sich Variablen und deren Werte in den Fenstern Auto und Lokal an.

   • Wenn der Debugger angehalten hat, können Sie auch die Fenster Überwachen und Aufrufliste verwenden.

3. Drücken Sie F11 erneut, um den Debugger um eine Zeile zu wechseln.

4. Drücken sie UMSCHALT+F11, oder wählen Sie Debuggen>Rücksprung aus, um in der verwalteten App mit der Ausführung fortzufahren und diese erneut anzuhalten.

5. Drücken Sie F5, oder wählen Sie den grünen Pfeil aus, um das Debuggen der App fortzusetzen.

Glückwunsch! Sie haben das Lernprogramm zum Debuggen im gemischten Modus abgeschlossen.

Nächster Schritt

In diesem Lernprogramm haben Sie gelernt, wie Sie systemeigenen Code aus einer verwalteten App debuggen, indem Sie das Debuggen im gemischten Modus aktivieren. Eine Übersicht über andere Debuggerfeatures finden Sie unter:

Erster Blick auf den Debugger