Zelfstudie: Fouten opsporen in C# en C++ in dezelfde foutopsporingssessie

Artikel
01/26/2025

Met Visual Studio kunt u meer dan één foutopsporingsprogrammatype inschakelen in een foutopsporingssessie. Dit wordt foutopsporing in de gemengde modus genoemd. In deze zelfstudie leert u hoe u fouten opspoort in zowel beheerde als systeemeigen code in één foutopsporingssessie.

In deze zelfstudie ziet u hoe u systeemeigen code van een beheerde app kunt opsporen, maar u kunt ook beheerde code van een systeemeigen app . Het foutopsporingsprogramma ondersteunt ook andere typen foutopsporing in de gemengde modus, zoals foutopsporing Python en systeemeigen code, en het gebruik van het scriptdebugger in app-typen zoals ASP.NET.

In deze zelfstudie gaat u het volgende doen:

Een eenvoudige systeemeigen DLL maken
Een eenvoudige .NET Core- of .NET Framework-app maken om het DLL-bestand aan te roepen
Foutopsporing in gemengde modus configureren
Het foutopsporingsprogramma starten
Een onderbrekingspunt in de beheerde app bereiken
Stap in de systeemeigen code

Voorwaarden

Visual Studio moet zijn geïnstalleerd met de volgende werkbelastingen:

Desktop-ontwikkeling met C++
.NET-desktopontwikkeling

Visual Studio moet zijn geïnstalleerd met de volgende werkbelastingen:

Desktop-ontwikkeling met C++
.NET-desktopontwikkeling of .NET Core cross-platformontwikkeling, afhankelijk van het type app dat u wilt maken.

Als u Visual Studio niet hebt, gaat u naar de Visual Studio-downloadpagina pagina om deze gratis te installeren.

Als Visual Studio is geïnstalleerd, maar niet over de workloads beschikt die u nodig hebt, selecteert u Visual Studio Installer openen in het linkerdeelvenster van het dialoogvenster Visual Studio Nieuw project. Selecteer in het Installatieprogramma van Visual Studio de werkbelastingen die u nodig hebt en selecteer vervolgens Wijzigen.

Een eenvoudige systeemeigen DLL maken

De bestanden voor het DLL-project maken:

Open Visual Studio en maak een project.

Druk op Esc om het startvenster te sluiten. Typ Ctrl+ Q om het zoekvak te openen, typ Leeg project, kies sjablonenen kies vervolgens Leeg project voor C++. Kies in het dialoogvenster dat wordt weergegeven maken. Typ vervolgens een naam in, zoals Mixed_Mode_Debugging, en klik op Maken.

Als u de projectsjabloon Leeg project niet ziet, gaat u naar Tools>Hulpprogramma's en functies ophalen…, waarmee het installatieprogramma van Visual Studio wordt geopend. Het installatieprogramma van Visual Studio wordt gestart. Kies de Desktop ontwikkeling met C++ workload en selecteer vervolgens Wijzig.

Visual Studio maakt het project.
Selecteer in Solution Explorerbronbestandenen selecteer vervolgens Project>Nieuw item toevoegen. Of klik met de rechtermuisknop op Bronbestanden en selecteer Toevoegen>Nieuw Item.

Als u niet alle itemsjablonen ziet, kiest u Alle sjablonen weergeven.
Selecteer in het dialoogvenster Nieuw item de optie C++-bestand (.cpp). Typ Mixed_Mode.cpp in het veld Naam en selecteer toevoegen.

Visual Studio voegt het nieuwe C++-bestand toe aan Solution Explorer-.
Kopieer de volgende code naar Mixed_Mode.cpp:
```
#include "Mixed_Mode.h"
```
Selecteer in Solution Explorerkoptekstbestandenen selecteer vervolgens Project>Nieuw item toevoegen. Of klik met de rechtermuisknop op koptekstbestanden en selecteer >Nieuw item toevoegen.

Als u niet alle itemsjablonen ziet, kiest u Alle sjablonen weergeven.
Selecteer in het dialoogvenster Nieuw item de optie headerbestand (.h). Typ Mixed_Mode.h in het veld Naam en selecteer toevoegen.

Visual Studio voegt het nieuwe headerbestand toe aan Solution Explorer-.

Kopieer de volgende code naar 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

Selecteer Bestand>Alle opslaan of druk op Ctrl+Shift+S om de bestanden op te slaan.

Het DLL-project configureren en bouwen:

Selecteer op de werkbalk van Visual Studio de configuratie Foutopsporing en x86 of x64 platform. Als uw aanroepende app .NET Core is, die altijd wordt uitgevoerd in de 64-bits modus, selecteert u x64- als platform.
Selecteer in Solution Explorerhet Mixed_Mode_Debugging projectknooppunt en selecteer het pictogram Eigenschappen of klik met de rechtermuisknop op het projectknooppunt en selecteer Eigenschappen.
Controleer boven in het deelvenster Eigenschappen of de Configuratie- is ingesteld op Active(Debug) en of de Platform- hetzelfde is als wat u hebt ingesteld op de werkbalk: x64-of Win32 voor x86-platform.

Belangrijk

Als u van platform overschakelt van x86- naar x64- of omgekeerd, moet u de eigenschappen voor het nieuwe platform opnieuw configureren.
Selecteer onder Configuratie-eigenschappen in het linkerdeelvenster Linker>Geavanceerden selecteer in de vervolgkeuzelijst naast Geen toegangspuntde optie Geen. Als u het moet wijzigen in Geen, selecteer dan Toepassen.
Selecteer onder Configuratie-eigenschappenAlgemeenen selecteer in de vervolgkeuzelijst naast configuratietypeDynamische bibliotheek (.dll). Selecteer toepassen en selecteer OK-.
Selecteer het project in Solution Explorer en selecteer vervolgens Build>Build Solution, druk op F7of klik met de rechtermuisknop op het project en selecteer Build.

Het project moet zonder fouten worden gebouwd.

Een eenvoudige beheerde app maken om de DLL aan te roepen

Open Visual Studio en maak een nieuw project.

Druk op Esc om het startvenster te sluiten. Typ Ctrl + Q om het zoekvak te openen, typ console, kies Sjablonenen kies Console-app voor .NET Core of Console App (.NET Framework) voor C#. Kies in het dialoogvenster dat wordt weergegeven Volgende.

Typ vervolgens een naam zoals Mixed_Mode_Calling_App en klik op Volgende of maken, afhankelijk van welke optie beschikbaar is.

Kies voor .NET Core het aanbevolen doelframework of .NET 8, en klik dan op Maken.

Als u de juiste projectsjabloon niet ziet, gaat u naar Tools>Hulpprogramma's en onderdelen ophalen..., waarmee het installatieprogramma van Visual Studio wordt geopend. Kies de juiste .NET-werkbelasting zoals beschreven in de vereisten en kies vervolgens Wijzigen.

Notitie

U kunt het nieuwe beheerde project ook toevoegen aan uw bestaande C++-oplossing. We maken het project in een nieuwe oplossing om de foutopsporingstaak in de gemengde modus moeilijker te maken.

Visual Studio maakt het lege project en geeft het weer in Solution Explorer-.

Vervang alle code in Program.cs door de volgende 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();
        }
    }
}

Vervang in de nieuwe code het bestandspad in [DllImport] door het bestandspad naar de Mixed_Mode_Debugging.dll die u zojuist hebt gemaakt. Zie de code-opmerking voor hints. Zorg ervoor dat u de plaatshouder voor de gebruikersnaam vervangt.
Selecteer Bestand>Opslaan Program.cs of druk op Ctrl+S- om het bestand op te slaan.

Foutopsporing in gemengde modus configureren

Selecteer in Solution Explorerhet Mixed_Mode_Calling_App projectknooppunt en selecteer het pictogram Eigenschappen of klik met de rechtermuisknop op het projectknooppunt en selecteer Eigenschappen.
Systeemeigen codeopsporing inschakelen in de eigenschappen.

.NET-code

Selecteer Foutopsporing in het linkerdeelvenster, selecteer Open de gebruikersinterface voor foutopsporingsprofielen, vink vervolgens het selectievakje Native code-debugging inschakelen aan, en sluit ten slotte de eigenschappenpagina om de wijzigingen op te slaan.

.NET Framework-code

Selecteer in het linkermenu Foutopsporing. Selecteer vervolgens in de sectie Foutopsporingsprogramma-engines de Systeemeigen codeopsporing inschakelen eigenschap en sluit vervolgens de eigenschappenpagina om de wijzigingen op te slaan.

Selecteer Foutopsporing in het linkerdeelvenster, schakel het selectievakje Systeemeigen codeopsporing inschakelen in en sluit vervolgens de eigenschappenpagina om de wijzigingen op te slaan.
Als u een x64-DLL van een .NET Framework-app wilt gebruiken, wijzigt u het platformdoel van Elke CPU- in x64. Hiervoor moet u mogelijk Configuration Manager selecteren in de vervolgkeuzelijst Oplossingsplatform van de werkbalk Debuggen. Als u vervolgens niet rechtstreeks naar x64 kunt overschakelen, maakt u een Nieuwe-configuratie die is gericht op x64.

Een onderbrekingspunt instellen en foutopsporing starten

Open Program.csin het C#-project. Stel een onderbrekingspunt in op de volgende regel code door in de verre linkermarge te klikken, de regel te selecteren en op F9te drukken, of door met de rechtermuisknop op de regel te klikken en Onderbrekingspunt te selecteren>Voeg onderbrekingspunt toe.
```
int result = Multiply(7, 7);
```
Er wordt een rode cirkel weergegeven in de linkermarge waar u het onderbrekingspunt instelt.
Druk op F5, selecteer de groene pijl op de werkbalk van Visual Studio of selecteer Foutopsporing>Start Debugging om foutopsporing te starten.

Het foutopsporingsprogramma pauzeert op het onderbrekingspunt dat u hebt ingesteld. Een gele pijl geeft aan waar het foutopsporingsprogramma momenteel is onderbroken.

Systeemeigen code in- en uitschakelen

Terwijl foutopsporing is onderbroken in de beheerde app, drukt u op F11of selecteert u Foutopsporing>Stap in.

Het Mixed_Mode.h systeemeigen headerbestand wordt geopend en u ziet de gele pijl waar de debugger is gepauzeerd.
U kunt nu onderbrekingspunten instellen en bereiken en variabelen controleren in de systeemeigen of beheerde code.
- Beweeg de muisaanwijzer over variabelen in de broncode om de bijbehorende waarden te bekijken.
- Bekijk de variabele en de bijbehorende waarden in de Autos en Locals vensters.
- Terwijl de uitvoering is onderbroken in het foutopsporingshulpmiddel, kunt u ook de Watch-vensters en het Call Stack-venster gebruiken.
Druk nogmaals op F11 om het foutopsporingsprogramma één regel verder te gaan.
Druk op Shift+F11 of selecteer Debug>Stap Uit om de uitvoering voort te zetten en opnieuw te pauzeren in de beheerde app.
Druk op F5 of selecteer de groene pijl om door te gaan met het opsporen van fouten in de app.

Gefeliciteerd! U hebt de tutorial over foutopsporing in de gemengde modus voltooid.

Volgende stap

In deze zelfstudie hebt u geleerd hoe u systeemeigen code van een beheerde app opspoort door foutopsporing in de gemengde modus in te schakelen. Zie voor een overzicht van andere functies voor foutopsporingsprogramma:

Bekijk eerst het foutopsporingsprogramma

Delen via