Samouczek: debugowanie języków C# i C++ w tej samej sesji debugowania

Program Visual Studio umożliwia włączenie więcej niż jednego typu debugera w sesji debugowania, która jest nazywana debugowaniem w trybie mieszanym. Z tego samouczka dowiesz się, jak debugować zarówno zarządzany, jak i natywny kod w jednej sesji debugowania.

W tym samouczku pokazano, jak debugować kod natywny z poziomu aplikacji zarządzanej, ale można również debugować kod zarządzany z poziomu aplikacji natywnej. Debuger obsługuje również inne typy debugowania w trybie mieszanym, takie jak debugowanie Python i kod natywnyoraz używanie debugera skryptów w typach aplikacji, takich jak ASP.NET.

W tym samouczku nauczysz się:

• Tworzenie prostej natywnej biblioteki DLL
• Tworzenie prostej aplikacji .NET Core lub .NET Framework w celu wywołania biblioteki DLL
• Konfigurowanie debugowania w trybie mieszanym
• Uruchamianie debugera
• Trafienie do punktu przerwania w aplikacji zarządzanej
• Przechodzenie do kodu natywnego

Warunki wstępne

Musisz mieć zainstalowany program Visual Studio z następującymi obciążeniami:

• Programowanie aplikacji klasycznych przy użyciu języka C++
• programowanie aplikacji desktopowych .NET

Jeśli nie masz programu Visual Studio, przejdź do strony Visual Studio do pobrania, aby ją zainstalować bezpłatnie.

Jeśli masz zainstalowany program Visual Studio, ale nie masz potrzebnych obciążeń, wybierz pozycję Otwórz Instalator programu Visual Studio w lewym okienku okna dialogowego Nowy projekt programu Visual Studio Nowy projekt. W Instalatorze programu Visual Studio wybierz potrzebne obciążenia, a następnie wybierz pozycję Modyfikuj.

Tworzenie prostej natywnej biblioteki DLL

Aby utworzyć pliki dla projektu DLL:

1. Otwórz program Visual Studio i utwórz projekt.

   Naciśnij Esc, aby zamknąć okno uruchamiania. Wpisz Ctrl + Q, aby otworzyć pole wyszukiwania, wpisz Pusty projekt, wybierz pozycję Templates, a następnie wybierz pozycję Pusty projekt dla C++. W wyświetlonym oknie dialogowym wybierz pozycję Utwórz. Następnie wpisz nazwę, taką jak Mixed_Mode_Debugging, i kliknij Utwórz.

   Jeśli nie widzisz szablonu projektu Empty Project, przejdź do Tools>Get Tools and Features..., co spowoduje otwarcie Instalatora programu Visual Studio. Zostanie uruchomiony Instalator programu Visual Studio. Wybierz pakiet roboczy Desktop z obciążeniem języka C++, a następnie wybierz pozycję Modyfikuj.

   Program Visual Studio tworzy projekt.

2. W eksploratorze rozwiązań wybierz pozycję Pliki źródłowe, a następnie wybierz pozycję Project>Dodaj nowy element. Możesz też kliknąć prawym przyciskiem myszy Pliki Źródłowe i wybrać Dodaj>Nowy Element.

   Jeśli nie widzisz wszystkich szablonów elementów, wybierz pozycję Pokaż wszystkie szablony.

3. W oknie dialogowym nowy element wybierz plik C++ (.cpp). Wpisz Mixed_Mode.cpp w polu nazwa, a następnie wybierz Dodaj.

   Program Visual Studio dodaje nowy plik C++ do eksploratora rozwiązań .

4. Skopiuj następujący kod do Mixed_Mode.cpp:

   #include "Mixed_Mode.h"
   

5. W Eksploratorze Rozwiązań wybierz pozycję Pliki nagłówkowe, a następnie wybierz pozycję Projekt>Dodaj nowy element. Lub kliknij prawym przyciskiem myszy Pliki nagłówka i wybierz Dodaj>Nowy element.

   Jeśli nie widzisz wszystkich szablonów elementów, wybierz pozycję Pokaż wszystkie szablony.

6. W oknie dialogowym nowy element wybierz pozycję Plik nagłówka (.h). Wpisz Mixed_Mode.h w polu Nazwa, a następnie wybierz Dodaj.

   Program Visual Studio dodaje nowy plik nagłówka do Eksplorator rozwiązań.

7. Skopiuj następujący kod do 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. Wybierz Plik>Zapisz wszystkie lub naciśnij Ctrl+Shift+S, aby zapisać pliki.

Aby skonfigurować i skompilować projekt DLL:

1. Na pasku narzędzi programu Visual Studio wybierz pozycję Debuguj konfigurację i x86 lub platformę x64. Jeśli aplikacja wywołująca będzie platformą .NET Core, która zawsze działa w trybie 64-bitowym, wybierz pozycję x64 jako platformę.

2. W Eksploratorze rozwiązań wybierz węzeł projektu Mixed_Mode_Debugging i następnie wybierz ikonę Właściwości, lub kliknij prawym przyciskiem myszy węzeł projektu i wybierz pozycję Właściwości .

3. W górnej części panelu Properties upewnij się, że Configuration jest ustawione na Active(Debug), a Platform jest ustawione tak samo jak na pasku narzędzi: x64lub Win32 dla platformy x86.

   Ważny

   Jeśli zmienisz platformę z x86 na x64 lub odwrotnie, musisz ponownie skonfigurować właściwości nowej platformy.

4. W sekcji właściwości konfiguracji w polu po lewej stronie wybierz pozycję Linker>Zaawansowane, a następnie na liście rozwijanej obok pozycji Brak punktu wejściawybierz pozycję Nie. Jeśli trzeba było zmienić ją na Nie, wybierz pozycję Zastosuj.

5. W obszarze właściwości konfiguracji wybierz pozycję Ogólne, a następnie na liście rozwijanej obok pozycji Typ konfiguracjiwybierz pozycję biblioteka dynamiczna (.dll). Wybierz pozycję Zastosuj, a następnie wybierz pozycję OK.

   

6. Wybierz projekt w eksploratorze rozwiązań , a następnie wybierz pozycję Build Solution>Build Solution, naciśnij F7lub kliknij projekt prawym przyciskiem myszy i wybierz pozycję Build.

   Projekt powinien skompilować się bez błędów.

Tworzenie prostej aplikacji zarządzanej w celu wywołania biblioteki DLL

1. Otwórz program Visual Studio i utwórz nowy projekt.

   Naciśnij Esc, aby zamknąć okno uruchamiania. Wpisz Ctrl + Q, aby otworzyć pole wyszukiwania, wpisz console, wybierz pozycję Szablony , a następnie wybierz pozycję Aplikacja konsolowa dla platformy .NET Core lub Aplikacja konsolowa (.NET Framework) dla języka C#. W wyświetlonym oknie dialogowym wybierz pozycję Dalej.

   Następnie wpisz nazwę, taką jak Mixed_Mode_Calling_App, a następnie kliknij przycisk Next lub Create( dowolna opcja jest dostępna).

   W przypadku platformy .NET Core wybierz zalecaną platformę docelową lub platformę .NET 8, a następnie wybierz pozycję Utwórz.

   Jeśli nie widzisz poprawnego szablonu projektu, przejdź do Tools>Get Tools and Features..., co spowoduje otwarcie Instalatora programu Visual Studio. Wybierz prawidłowe obciążenie .NET zgodnie z opisem w wymaganiach wstępnych, a następnie wybierz pozycję Modyfikuj.

   Notatka

   Możesz również dodać nowy projekt zarządzany do istniejącego rozwiązania C++. Tworzymy projekt w nowym rozwiązaniu, aby utrudnić zadanie debugowania w trybie mieszanym.

   Program Visual Studio tworzy pusty projekt i wyświetla go w eksploratorze rozwiązań .

2. Zastąp cały kod w Program.cs następującym kodem:

   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. W nowym kodzie zastąp ścieżkę pliku w [DllImport] ścieżką pliku do właśnie utworzonego Mixed_Mode_Debugging.dll. Zobacz komentarz do kodu, aby uzyskać wskazówki. Pamiętaj, aby zastąpić nazwę użytkownika symbolem zastępczym.

4. Wybierz pozycję Plik>Zapisz Program.cs lub naciśnij Ctrl+S, aby zapisać plik.

Konfigurowanie debugowania w trybie mieszanym

1. W eksploratorze rozwiązań wybierz węzeł projektu Mixed_Mode_Calling_App i wybierz ikonę właściwości lub kliknij prawym przyciskiem myszy węzeł projektu i wybierz pozycję właściwości .

2. Włącz debugowanie kodu natywnego we właściwościach.

   kod .NET

   Wybierz pozycję Debug w lewym panelu, wybierz Otwórz interfejs profilów uruchamiania debugowania, następnie zaznacz pole Włącz debugowanie kodu natywnego i zamknij stronę właściwości, aby zapisać zmiany.

   

   kodu programu .NET Framework

   W menu po lewej stronie wybierz pozycję Debug. Następnie w sekcji silników debugera wybierz właściwość Włącz debugowanie kodu natywnego, a następnie zamknij stronę właściwości, aby zapisać zmiany.

3. Jeśli docelowa biblioteka DLL w aplikacji .NET Framework to x64, zmień ustawienia platformy z Dowolny procesor na x64. W tym celu może być konieczne wybranie Configuration Manager z listy rozwijanej platformy rozwiązania na pasku narzędzi debugowania. Następnie, jeśli nie możesz przełączyć się bezpośrednio na x64, utwórz Nową Konfigurację, która jest przeznaczona dla x64.

Ustawianie punktu przerwania i rozpoczynanie debugowania

1. W projekcie języka C# otwórz Program.cs. Ustaw punkt przerwania w następującym wierszu kodu, klikając lewy margines, wybierając wiersz i naciskając F9 F9lub klikając wiersz prawym przyciskiem myszy i wybierając punkt przerwania>Wstaw punkt przerwania.

   int result = Multiply(7, 7);
   

   Czerwony okrąg pojawia się na lewym marginesie, w którym ustawiono punkt przerwania.

2. Naciśnij F5, wybierz zieloną strzałkę na pasku narzędzi programu Visual Studio lub wybierz pozycję Debugowanie>Rozpocznij debugowanie, aby rozpocząć debugowanie.

   Debuger wstrzymuje się w ustawionym punkcie przerwania. Żółta strzałka wskazuje, gdzie debuger jest obecnie wstrzymany.

Przechodzenie do i z kodu natywnego

1. Podczas debugowania w aplikacji zarządzanej naciśnij F11lub wybierz pozycję Debug>Wejdź do.

   Plik nagłówkowy natywny Mixed_Mode.h otworzy się, a żółta strzałka wskaże miejsce, w którym wstrzymano działanie debugera.

   

2. Teraz możesz ustawić i aktywować punkty przerwania oraz sprawdzić zmienne w kodzie natywnym lub zarządzanym.

   • Umieść kursor na zmiennych w kodzie źródłowym, aby wyświetlić ich wartości.

   • Przyjrzyj się zmiennym i ich wartościom w oknach Autos i Locals.

   • Podczas wstrzymania w debugerze można również użyć okien Watch oraz okna stos wywołań .

3. Naciśnij ponownie F11, aby przejść o jedną linię w debugowaniu.

4. Naciśnij Shift+F11 lub wybierz pozycję Debugowanie>, aby kontynuować wykonywanie i wstrzymać ponownie w aplikacji zarządzanej.

5. Naciśnij F5 lub wybierz zieloną strzałkę, aby kontynuować debugowanie aplikacji.

Gratulacje! Ukończono samouczek dotyczący debugowania w trybie mieszanym.

Następny krok

W tym samouczku przedstawiono sposób debugowania kodu natywnego z poziomu aplikacji zarządzanej przez włączenie debugowania w trybie mieszanym. Aby zapoznać się z omówieniem innych funkcji debugera, zobacz:

Pierwsze spojrzenie na debuggera