Självstudie: Felsöka C# och C++ i samma felsökningssession

Med Visual Studio kan du aktivera mer än en felsökningstyp i en felsökningssession, som kallas felsökning i blandat läge. I den här självstudien lär du dig att felsöka både hanterad och intern kod i en enda felsökningssession.

Denna handledning visar hur du felsöker native kod från en hanterad applikation, däremot kan du också felsöka hanterad kod från en inbyggd applikation. Felsökningsprogrammet stöder även andra typer av felsökning i blandat läge, till exempel felsökning Python och inbyggd kodoch användning av skriptfelsökaren i apptyper som ASP.NET.

I den här guiden kommer du att:

• Skapa en enkel inbyggd DLL
• Skapa en enkel .NET Core- eller .NET Framework-app för att anropa DLL:en
• Konfigurera felsökning i blandat läge
• Starta felsökningsprogrammet
• Träffa en brytpunkt i den hanterade appen
• Stega in i den interna koden

Förutsättningar

Du måste ha Visual Studio installerat med följande arbetsbelastningar:

• Desktop-utveckling med C++
• .NET-skrivbordsutveckling

Om du inte har Visual Studio går du till sidan för Visual Studio-nedladdningar för att installera den kostnadsfritt.

Om du har Visual Studio installerat, men inte har de arbetsbelastningar du behöver, väljer du Öppna Visual Studio Installer i den vänstra rutan i dialogrutan Visual Studio New Project. I Visual Studio Installer väljer du de arbetsbelastningar du behöver och väljer sedan Ändra.

Skapa en enkel inbyggd DLL

Så här skapar du filerna för DLL-projektet:

1. Öppna Visual Studio och skapa ett projekt.

   Tryck på Esc för att stänga startfönstret. Skriv Ctrl + Q för att öppna sökrutan, skriv Tomt projekt, välj mallaroch välj sedan Tomt projekt för C++. I dialogrutan som visas väljer du Skapa. Skriv sedan ett namn som Mixed_Mode_Debugging och klicka på Skapa.

   Om du inte ser projektmallen Empty Project går du till Tools>Hämta verktyg och funktioner..., som öppnar Installationsprogrammet för Visual Studio. Visual Studio Installer startas. Välj Desktop-utveckling med C++ arbetsbelastning och välj sedan Ändra.

   Visual Studio skapar projektet.

2. I Solution Explorerväljer du Källfileroch väljer sedan Project>Lägg till nytt objekt. Du kan också högerklicka på Källfiler och välja Lägg till>nytt objekt.

   Om du inte ser alla objektmallar väljer du Visa alla mallar.

3. I dialogrutan Nytt objekt väljer du C++-fil (.cpp). Skriv Mixed_Mode.cpp i fältet Namn och välj sedan Lägg till.

   Visual Studio lägger till den nya C++-filen i Solution Explorer.

4. Kopiera följande kod till Mixed_Mode.cpp:

   #include "Mixed_Mode.h"
   

5. I Solution Explorerväljer du Huvudfileroch väljer sedan Project>Lägg till nytt objekt. Du kan också högerklicka på Rubrikfiler och välja Lägg till>Nytt Objekt.

   Om du inte ser alla objektmallar väljer du Visa alla mallar.

6. I dialogrutan Nytt objekt väljer du Rubrikfil (.h). Skriv Mixed_Mode.h i fältet Namn och sedan välj Lägg till.

   Visual Studio lägger till den nya huvudfilen i Solution Explorer.

7. Kopiera följande kod till 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. Välj Fil>Spara alla eller tryck på Ctrl+Skift+S för att spara filerna.

Konfigurera och skapa DLL-projektet:

1. I Visual Studio-verktygsfältet väljer du Felsöka konfiguration och x86 eller x64 plattform. Om din anropande app ska vara .NET Core, som alltid körs i 64-bitarsläge, väljer du x64 som plattform.

2. I Solution Explorerväljer du projektnoden Mixed_Mode_Debugging och väljer ikonen Egenskaper eller högerklickar på projektnoden och väljer Egenskaper.

3. Överst i fönstret Egenskaper kontrollerar du att Configuration är inställd på Active(Debug) och Platform är samma som du angav i verktygsfältet: x64eller Win32 för x86-plattformen.

   Viktig

   Om du byter plattform från x86 till x64 eller vice versa måste du konfigurera om egenskaperna för den nya plattformen.

4. Under Konfigurationsegenskaper i det vänstra fönstret väljer du Linker>Avanceratoch i listrutan bredvid Ingen startpunktväljer du Nej. Om du var tvungen att ändra den till Nejväljer du Använd.

5. Under Konfigurationsegenskaperväljer du Allmäntoch i listrutan bredvid konfigurationstypväljer du dynamiskt bibliotek (.dll). Välj Användoch välj sedan OK.

   

6. Välj projektet i Solution Explorer och välj sedan Build>Build Solution, tryck på F7eller högerklicka på projektet och välj Build.

   Projektet bör byggas utan fel.

Skapa en enkel hanterad app för att anropa DLL

1. Öppna Visual Studio och skapa ett nytt projekt.

   Tryck på Esc för att stänga startfönstret. Skriv Ctrl + Q för att öppna sökrutan, skriv -konsolen, välj Mallaroch välj sedan Console App för .NET Core eller Console App (.NET Framework) för C#. I dialogrutan som visas väljer du Nästa.

   Skriv sedan ett namn som Mixed_Mode_Calling_App och klicka på Nästa eller Skapa, beroende på vilket alternativ som är tillgängligt.

   För .NET Core väljer du antingen det rekommenderade målramverket eller .NET 8 och väljer sedan Skapa.

   Om du inte ser rätt projektmall går du till Verktyg>Hämta verktyg och funktioner..., som öppnar Installationsprogrammet för Visual Studio. Välj rätt .NET-arbetsbelastning enligt beskrivningen i förhandskraven och välj sedan Ändra.

   Not

   Du kan också lägga till det nya hanterade projektet i din befintliga C++-lösning. Vi skapar projektet i en ny lösning för att göra felsökningsaktiviteten i blandat läge svårare.

   Visual Studio skapar det tomma projektet och visar det i Solution Explorer.

2. Ersätt all kod i Program.cs med följande kod:

   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. I den nya koden ersätter du filsökvägen i [DllImport] med filsökvägen till den Mixed_Mode_Debugging.dll du nyss skapade. Se kodkommentare för tips. Ersätt platshållaren för användarnamnet.

4. Välj Fil>Spara Program.cs eller tryck på Ctrl+S för att spara filen.

Konfigurera felsökning i blandat läge

1. I Solution Explorerväljer du projektnoden Mixed_Mode_Calling_App och väljer ikonen Egenskaper eller högerklickar på projektnoden och väljer Egenskaper.

2. Aktivera intern kodfelsökning i egenskaperna.

   .NET-kod

   Välj Felsök i det vänstra fönstret, välj Öppna användargränssnittet för startprofiler för felsökningoch markera sedan kryssrutan Aktivera intern kodfelsökning och stäng sedan egenskapssidan för att spara ändringarna.

   

   .NET Framework-kod

   På den vänstra menyn väljer du Felsök. I avsnittet Felsökningsmotorer väljer du sedan egenskapen Aktivera intern kodfelsökning och stänger sedan egenskapssidan för att spara ändringarna.

3. Om du riktar in dig på en x64-DLL från en .NET Framework-app ändrar du plattformsmålet från Alla CPU- till x64. För att göra detta kan du behöva välja Configuration Manager i listrutan Lösningsplattform i verktygsfältet Felsökning. Om du inte kan växla till x64 direkt skapar du sedan en Ny-konfiguration som är avsedd för x64.

Ange en brytpunkt och börja felsöka

1. I C#-projektet öppnar du Program.cs. Ange en brytpunkt på följande kodrad genom att klicka längst till vänster, välja raden och trycka på F9eller högerklicka på raden och välja Brytpunkt>Infoga brytpunkt.

   int result = Multiply(7, 7);
   

   En röd cirkel visas i vänstermarginalen där du anger brytpunkten.

2. Tryck på F5, välj den gröna pilen i Visual Studio-verktygsfältet eller välj Felsök>Starta felsökning för att starta felsökningen.

   Felsökningsprogrammet stannar vid den brytpunkt som du har angett. En gul pil anger var felsökaren för närvarande är pausad.

Stega in och ut ur inbyggd kod

1. När felsökningen pausas i den hanterade appen trycker du på F11eller väljer Felsöka>Stega in i.

   Den Mixed_Mode.h- nativa huvudfilen öppnas, och du ser den gula pilen där felsökningsprogrammet har pausats.

   

2. Nu kan du ange och träffa brytpunkter och inspektera variabler i den interna eller hanterade koden.

   • Hovra över variabler i källkoden för att se deras värden.

   • Titta på variablerna och deras värden i fönstren Autos och Locals.

   • När du har pausat felsökningsprogrammet kan du också använda fönstret Watch och fönstret Call Stack.

3. Tryck på F11 igen för att föra felsökningsprogrammet framåt en rad.

4. Tryck på Skift+F11 eller välj Felsök>Steg ut för att fortsätta körningen och pausa igen i den hanterade appen.

5. Tryck på F5 eller välj den gröna pilen för att fortsätta felsöka appen.

Grattis! Du har slutfört självstudien om felsökning i blandat läge.

Nästa steg

I denna handledning har du lärt dig hur du felsöker native-kod från en hanterad applikation genom att aktivera felsökning i blandat läge (mixed mode). En översikt över andra felsökningsfunktioner finns i:

Första titt på felsökningsprogrammet