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

Artikel
10/19/2023

In Visual Studio können Sie mehr als einen Debugtyp in einer Debugsitzung aktivieren. Dies wird als Debuggen im gemischten Modus bezeichnet. In diesem Tutorial lernen Sie das Debuggen verwalteten und nativen Codes in einer einzigen Debugsitzung.

Sie lernen, wie Sie nativen Code aus einer verwalteten App debuggen, aber Sie können auch verwalteten Code aus einer nativen App debuggen. Der Debugger unterstützt auch andere Typen des Debuggens im gemischten Modus, wie z.B. das Debuggen von Python- und nativem Code und das Verwenden des Skriptdebuggers in App-Typen wie ASP.NET.

In diesem Tutorial werden Sie Folgendes durchführen:

Erstellen einer einfachen nativen DLL
Erstellen einer einfachen .NET Core- oder .NET Framework-App, die die DLL aufruft
Konfigurieren des Debuggens im gemischten Modus
Starten des Debuggers
Erreichen eines Breakpoints in der verwalteten App
Schrittweise Ausführung des nativen Codes

Voraussetzungen

Visual Studio muss in den folgenden Workloads installiert sein:

Desktopentwicklung mit C++
.NET Desktopentwicklung

Visual Studio muss in den folgenden Workloads installiert sein:

Desktopentwicklung mit C++
.NET-Desktopentwicklung oder Plattformübergreifende .NET Core-Entwicklung, je nachdem, welchen App-Typ Sie erstellen möchten.

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

Falls Sie bereits über Visual Studio verfügen, aber die Workloads noch installieren müssen, klicken Sie im linken Bereich des Dialogfelds Neues Projekt auf den Link Visual Studio-Installer öffnen. Wählen Sie im Visual Studio-Installer die benötigten Workloads aus, und klicken Sie dann auf Modify (Anpassen).

Erstellen einer einfachen nativen DLL

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

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

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

Wenn die Projektvorlage Leeres Projekt nicht angezeigt wird, öffnen Sie unter Tools>Tools und Features abrufen... den Visual Studio-Installer. Der Visual Studio-Installer wird gestartet. Wählen Sie die Workload Desktopentwicklung mit C++ , und klicken Sie dann auf Ändern.

Visual Studio erstellt daraufhin das Projekt.
Wählen Sie im Projektmappen-ExplorerQuelldateien aus, und klicken sie dann auf Projekt>Neues Element hinzufügen. Klicken Sie alternativ auf Quelldateien, und wählen Sie Hinzufügen>Neues Element aus.

Wenn nicht alle Elementvorlagen angezeigt werden, wählen Sie Alle Vorlagen anzeigen aus.
Klicken Sie im Dialogfeld Neues Element auf C++-Datei (.cpp) . Geben Sie im Feld NameMixed_Mode.cpp ein, und klicken Sie dann auf Hinzufügen.

Visual Studio fügt eine neue C++-Datei im Projektmappen-Explorer hinzu.
Kopieren Sie den folgenden Code in die Datei Mixed_Mode.cpp:
```
#include "Mixed_Mode.h"
```
Wählen Sie im Projektmappen-ExplorerHeaderdateien aus, und klicken sie dann auf Projekt>Neues Element hinzufügen. 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 anzeigen aus.
Klicken Sie im Dialogfeld Neues Element auf Headerdatei (.h) . Geben Sie im Feld NameMixed_Mode.h ein, und klicken Sie dann auf Hinzufügen.

Visual Studio fügt eine neue Headerdatei im Projektmappen-Explorer hinzu.

Kopieren Sie den folgenden Code in die Datei 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

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

So erstellen und konfigurieren Sie das DLL-Projekt:

Wählen Sie auf der Visual Studio-Symbolleiste die Konfiguration Debuggen und entweder x86 oder x64 für die Plattform aus. Wenn die aufrufende App eine .NET Core-App ist, die immer im 64-Bit-Modus ausgeführt wird, wählen Sie x64 als Plattform aus.
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.
Achten Sie darauf, dass die Konfiguration oben im Eigenschaftenpanel auf Active(Debug) festgelegt ist und die Plattform mit der in der Symbolleiste angegeben Einstellung übereinstimmt (x64 oder Win32 für die x86-Plattform).

Wichtig

Wenn Sie die Plattform von x86 in x64 (oder andersherum) ändern, müssen Sie die Eigenschaften für die neue Plattform erneut festlegen.
Wählen Sie links unter KonfigurationseigenschaftenLinker>Erweitert aus, und wählen Sie in der Dropdownliste neben Kein EinstiegspunktNein aus. Wenn Sie die Einstellung in Nein geändert haben, klicken Sie auf Anwenden.
Wählen Sie unter KonfigurationseigenschaftenAllgemein aus, und wählen Sie aus der Dropdownliste neben KonfigurationstypDynamische Bibliothek (DLL) aus. Klicken Sie auf Anwenden und dann auf OK.
Wählen Sie das Projekt im Projektmappen-Explorer 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 klicken Sie auf Erstellen.

Das Projekt wird fehlerfrei erstellt.

Erstellen einer einfachen verwalteten App, die die DLL aufruft

Ö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 Konsole ein, und klicken Sie auf Vorlagen. Wählen Sie anschließend Konsolen-App für .NET Core oder Konsolen-App (.NET Framework) für C# aus. Wählen Sie im angezeigten Dialogfeld Weiter aus.

Geben Sie dann einen Namen wie Mixed_Mode_Calling_App ein, und klicken Sie je nach verfügbarer Option entweder auf Weiter oder auf Erstellen.

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

Wenn die richtige Projektvorlage nicht angezeigt wird, navigieren Sie zu Tools>Tools und Features abrufen,um den Visual Studio-Installer zu öffnen. Wählen Sie die richtige .NET-Workload aus, wie in den Voraussetzungen beschrieben, und wählen Sie dann Ändern aus.

Hinweis

Sie können das neue verwaltete Projekt auch Ihrer vorhandenen C++-Projektmappe hinzufügen. Wir erstellen das Projekt in einer neuen Projektmappe, um das Debuggen im gemischten Modus schwieriger zu gestalten.

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

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

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();
        }
    }
}

Ersetzen Sie im neuen Code den Dateipfad in [DllImport] durch den Dateipfad zur Mixed_Mode_Debugging.dll, die Sie gerade erstellt haben. Weitere Informationen finden Sie in den Codekommentaren. Achten Sie darauf, dass Sie den Platzhalter username entsprechend ersetzen.
Klicken Sie auf Datei>Save Program.cs (Program.cs speichern), oder drücken Sie STRG+S, um die Datei zu speichern.

Konfigurieren des Debuggens im gemischten Modus

Wählen Sie im Projektmappen-Explorer den Projektknoten Mixed_Mode_Calling_App aus, und klicken Sie auf das Eigenschaftensymbol. Klicken Sie alternativ auf den Projektknoten und dann auf Eigenschaften.
Aktivieren Sie das native Codedebugging in den Eigenschaften.

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.

Wählen Sie im rechten Bereich Debuggen aus, aktivieren Sie das Kontrollkästchen Debuggen von nativem Code aktivieren, und schließen Sie anschließend die Eigenschaftenseite, um die Änderungen zu speichern.
Wenn Sie aus einer .NET Framework-App auf eine x64-DLL abzielen, ändern Sie das Plattformziel von Jede CPU auf x64. Dazu müssen Sie möglicherweise Configuration Manager aus der Dropdownliste „Projektmappenplattform“ der Debuggen-Symbolleiste auswählen. Wenn Sie dann nicht direkt zu x64 wechseln können, erstellen Sie eine Neue Konfiguration, die auf x64 ausgerichtet ist.

Festlegen eines Breakpoints und Starten des Debuggens

Öffnen Sie im C#-Projekt die Datei 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 an der Stelle des Breakpoints ein roter Kreis angezeigt.
Drücken Sie F5, und klicken Sie auf den grünen Pfeil auf der Visual Studio-Symbolleiste, oder klicken Sie auf Debuggen>Debuggen starten, um das Debuggen zu starten.

Der Debugger hält an dem Breakpoint an, den Sie festlegen. Ein gelber Pfeil markiert die Stelle, an der der Debugger gerade angehalten hat.

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

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.
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.
Drücken Sie erneut F11, um den Debugger eine Zeile weiter laufen zu lassen.
Drücken sie UMSCHALT+F11, oder klicken Sie auf Debuggen>Ausführen bis Rücksprung, um in der verwalteten App mit der Ausführung fortzufahren und diese anzuhalten.
Drücken Sie F5, oder klicken Sie auf den grünen Pfeil, um mit dem Debuggen der App fortzufahren.

Herzlichen Glückwunsch! Damit haben Sie das Tutorial zum Debuggen im gemischten Modus abgeschlossen.

Nächster Schritt

In diesem Tutorial haben Sie gelernt, wie Sie nativen Code einer verwalteten App debuggen, indem Sie das Debuggen im gemischten Modus aktivieren. Einen Überblick über andere Debuggerfeatures finden Sie in folgendem Artikel:

Erster Einblick in den Debugger

Freigeben über