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 języka Python i kodu natywnego, oraz używanie debugera skryptów w typach aplikacji, takich jak ASP.NET.

Ten samouczek obejmuje następujące kroki:

• 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

Wymagania wstępne

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

• Programowanie aplikacji klasycznych za pomocą języka C++
• Programowanie aplikacji klasycznych platformy .NET

Jeśli nie masz programu Visual Studio, przejdź do strony pobierania programu Visual Studio, aby zainstalować ją 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. W Instalator 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 klawisz Esc , aby zamknąć okno uruchamiania. Wpisz Ctrl + Q , aby otworzyć pole wyszukiwania, wpisz Pusty projekt, wybierz pozycję Szablony, a następnie wybierz pozycję Pusty projekt dla języka C++. W wyświetlonym oknie dialogowym wybierz pozycję Utwórz. Następnie wpisz nazwę, taką jak Mixed_Mode_Debugging , a następnie kliknij przycisk Utwórz.

   Jeśli nie widzisz szablonu pustego projektu projektu, przejdź do pozycji Narzędzia Pobierz narzędzia>i funkcje..., co spowoduje otwarcie Instalator programu Visual Studio. Zostanie uruchomiona Instalator programu Visual Studio. Wybierz pakiet roboczy Programowanie aplikacji klasycznych przy użyciu języka C++ , a następnie wybierz pozycję Modyfikuj.

   Program Visual Studio tworzy projekt.

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

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

3. W oknie dialogowym Nowy element wybierz pozycję Plik C++ (cpp). Wpisz Mixed_Mode.cpp w polu Nazwa , a następnie wybierz pozycję Dodaj.

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

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

   #include "Mixed_Mode.h"
   

5. W Eksplorator rozwiązań wybierz pozycję Pliki nagłówka, a następnie wybierz pozycję Projekt>Dodaj nowy element. Możesz też kliknąć prawym przyciskiem myszy pozycję Pliki nagłówka i wybrać polecenie 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 pozycję Dodaj.

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

7. Skopiuj następujący kod do pliku 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 pozycję Plik>Zapisz wszystko lub naciśnij klawisze 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 platformę x86 lub 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 Eksplorator rozwiązań wybierz węzeł projektu Mixed_Mode_Debugging i 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 okienka Właściwości upewnij się, że konfiguracja jest ustawiona na Wartość Active(Debug), a platforma jest taka sama jak ustawiona na pasku narzędzi: x64 lub Win32 dla platformy x86.

   Ważne

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

4. W obszarze Właściwości konfiguracji w okienku po lewej stronie wybierz pozycję Zaawansowane konsolidatora>, a następnie na liście rozwijanej obok pozycji Brak punktu wejścia wybierz 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 konfiguracji wybierz pozycję Biblioteka dynamiczna (dll). Wybierz Zastosuj, a następnie wybierz OK.

   

6. Wybierz projekt w Eksplorator rozwiązań, a następnie wybierz pozycję Kompiluj>rozwiązanie kompilacji, naciśnij klawisz F7 lub kliknij prawym przyciskiem myszy projekt i wybierz pozycję Kompiluj.

   Projekt powinien być kompilowany 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 klawisz Esc , aby zamknąć okno uruchamiania. Wpisz ctrl + Q , aby otworzyć pole wyszukiwania, wpisz konsolę, 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 Dalej lub Utwórz, niezależnie od dostępnej opcji.

   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 pozycji Narzędzia Pobierz narzędzia>i funkcje..., co spowoduje otwarcie Instalator programu Visual Studio. Wybierz odpowiednie obciążenie platformy .NET zgodnie z opisem w wymaganiach wstępnych, a następnie wybierz pozycję Modyfikuj.

   Uwaga

   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 Eksplorator rozwiązań.

2. Zastąp cały kod w pliku 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] pliku ścieżką do właśnie utworzonej biblioteki Mixed_Mode_Debugging.dll . Zobacz komentarz do kodu, aby uzyskać wskazówki. Pamiętaj, aby zastąpić symbol zastępczy nazwy użytkownika .

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

Konfigurowanie debugowania w trybie mieszanym

1. W Eksplorator 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.

   Wybierz pozycję Debuguj w okienku po lewej stronie, wybierz pozycję Otwórz interfejs użytkownika profilów uruchamiania debugowania, a następnie zaznacz pole wyboru Włącz debugowanie kodu natywnego, a następnie zamknij stronę właściwości, aby zapisać zmiany.

3. Jeśli używasz biblioteki DLL x64 z aplikacji .NET Framework, zmień docelową platformę z Dowolnego procesora CPU na x64. W tym celu może być konieczne wybranie programu Configuration Manager z listy rozwijanej Platforma 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ę docelową x64.

Ustawianie punktu przerwania i rozpoczynanie debugowania

1. W projekcie języka C# otwórz plik Program.cs. Ustaw punkt przerwania w następującym wierszu kodu, klikając lewy margines, wybierając wiersz i naciskając klawisz F9 lub klikając wiersz prawym przyciskiem myszy i wybierając pozycję 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 klawisz F5, wybierz zieloną strzałkę na pasku narzędzi programu Visual Studio lub wybierz pozycję Debuguj>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 klawisz F11 lub wybierz pozycję Debuguj>krok do.

   Zostanie otwarty plik nagłówka natywnego Mixed_Mode.h i zobaczysz żółtą strzałkę, w której wstrzymano debuger.

   

2. Teraz możesz ustawić i trafić do punktów przerwania i 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ę zmiennej i ich wartości w oknach Autos i Locals .

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

3. Naciśnij klawisz F11 ponownie, aby przejść do jednego wiersza debugera.

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

5. Naciśnij klawisz 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 debugera