Tutorial: Depurar C# e C++ na mesma sessão de depuração

O Visual Studio permite habilitar mais de um tipo de depurador em uma sessão de depuração, que é chamada de depuração de modo misto. Neste tutorial, você aprenderá a depurar código gerenciado e nativo em uma única sessão de depuração.

Este tutorial mostra como depurar código nativo de um aplicativo gerenciado, mas você também pode depurar código gerenciado de um aplicativo nativo. O depurador também dá suporte a outros tipos de depuração de modo misto, como a depuração de Python e código nativo e ao uso do depurador de scripts em tipos de aplicativo, como o ASP.NET.

Neste tutorial, você irá:

• Criar uma DLL nativa simples
• Criar um aplicativo .NET Core ou .NET Framework simples para chamar a DLL
• Configurar a depuração de modo misto
• Iniciar o depurador
• Atingir um ponto de interrupção no aplicativo gerenciado
• Intervir no código nativo

Pré-requisitos

Você deve ter o Visual Studio instalado, com as seguintes cargas de trabalho:

• Desenvolvimento para desktop com C++
• Desenvolvimento da área de trabalho do .NET

Se você não tiver o Visual Studio, vá para a página downloads do Visual Studio para instalá-lo gratuitamente.

Se você tiver o Visual Studio instalado, mas não tiver as cargas de trabalho necessárias, selecione Abrir o Instalador do Visual Studio no painel esquerdo da caixa de diálogo Novo Projeto do Visual Studio. No Instalador do Visual Studio, selecione as cargas de trabalho necessárias e selecione Modificar.

Criar uma DLL nativa simples

Para criar os arquivos para o projeto DLL:

1. Abra o Visual Studio e crie um projeto.

   Pressione Esc para fechar a janela inicial. Digite Ctrl + Q para abrir a caixa de pesquisa, digite Projeto Vazio, escolha Templates, e em seguida escolha Projeto Vazio para C++. Na caixa de diálogo exibida, escolha Criar. Em seguida, digite um nome como Mixed_Mode_Debugging e clique em criar.

   Se você não vir o modelo de projeto Projeto Vazio, acesse Ferramentas>Obter Ferramentas e Recursos..., que abre o Instalador do Visual Studio. O Visual Studio Installer é iniciado. Escolha a carga de trabalho Desenvolvimento para desktop com C++ e, em seguida, selecione Modificar.

   O Visual Studio cria o projeto.

2. No Gerenciador de Soluções , selecione Arquivos de Origeme, em seguida, selecione Projeto>Adicionar Novo Item. Ou clique com o botão direito do mouse em Arquivos de Origem e selecione Adicionar>Novo Item.

   Caso você não veja todos os modelos de item, escolha Mostrar todos os modelos.

3. Na caixa de diálogo Novo Item, selecione arquivo C++ (.cpp). Digite Mixed_Mode.cpp no campo Nome e, em seguida, selecione Adicionar.

   O Visual Studio adiciona o novo arquivo C++ ao Gerenciador de Soluções.

4. Copie o seguinte código para Mixed_Mode.cpp:

   #include "Mixed_Mode.h"
   

5. No Gerenciador de Soluções, selecione Arquivos de Cabeçalho e, em seguida, selecione Projeto>Adicionar Novo Item. Ou, clique com o botão direito do mouse em Arquivos de Cabeçalho e selecione Adicionar>Novo Item.

   Caso você não veja todos os modelos de item, escolha Mostrar todos os modelos.

6. Na caixa de diálogo Novo Item, selecione Arquivo de cabeçalho (.h). Digite Mixed_Mode.h no campo Nome e, em seguida, selecione Adicionar.

   O Visual Studio adiciona o novo arquivo de cabeçalho ao Gerenciador de Soluções .

7. Copie o seguinte código para 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. Selecione Arquivo>Salvar Todos ou pressione Ctrl+Shift+S para salvar os arquivos.

Para configurar e criar o projeto DLL:

1. Na barra de ferramentas do Visual Studio, selecione a configuração de Depuração e a plataforma x86 ou x64. Se o aplicativo de chamada será o .NET Core, que sempre é executado no modo de 64 bits, selecione x64 como a plataforma.

2. No Gerenciador de Soluções, selecione o nó do projeto Mixed_Mode_Debugging e escolha o ícone Propriedades ou clique com o botão direito do mouse no nó do projeto e selecione Propriedades.

3. Na parte superior do painel Propriedades, verifique se a Configuração está definida como Active(Debug) e a Plataforma é a mesma que você definiu na barra de ferramentas: x64 ou Win32 para a plataforma x86.

   Importante

   Se você mudar a plataforma de x86 para x64 ou vice-versa, reconfigure as propriedades da nova plataforma.

4. Nas Propriedades de Configuração no painel esquerdo, selecione Vinculador>Avançado e, no menu suspenso ao lado de Nenhum Ponto de Entrada, selecione Não. Se você tiver que alterá-lo para Sem, selecione Aplicar.

5. Em Propriedades de Configuração, selecione Gerale, na lista suspensa ao lado de Tipo de Configuração, selecione Biblioteca Dinâmica (.dll). Selecione Aplicare selecione OK.

   

6. Selecione o projeto no Gerenciador de Soluções e, em seguida, selecione Compilar>Compilar Solução, pressione F7 ou clique com o botão direito do mouse no projeto e selecione Compilar.

   O projeto deve ser compilado sem erros.

Criar um aplicativo gerenciado simples para chamar a DLL

1. Abra o Visual Studio e crie um novo projeto.

   Pressione Esc para fechar a janela inicial. Digite Ctrl + Q para abrir a caixa de pesquisa, digite console, escolha Modelose escolha Aplicativo de Console para o .NET Core ou Console App (.NET Framework) para C#. Na caixa de diálogo exibida, escolha Próximo.

   Em seguida, digite um nome como Mixed_Mode_Calling_App e clique em Avançar ou em Criar, a opção que estiver disponível.

   Para o .NET Core, escolha a estrutura de destino recomendada ou o .NET 8 e escolha Criar.

   Se você não vir o modelo de projeto correto, vá para Ferramentas>Obter Ferramentas e Recursos..., que abre o Instalador do Visual Studio. Escolha a carga de trabalho correta do .NET conforme descrito nos pré-requisitos e escolha Modificar.

   Nota

   Você também pode adicionar o novo projeto gerenciado à solução C++ existente. Estamos criando o projeto em uma nova solução para dificultar a tarefa de depuração no modo misto.

   O Visual Studio cria o projeto vazio e o exibe no Gerenciador de Soluções.

2. Substitua todo o código no Program.cs pelo seguinte código:

   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. No novo código, substitua o caminho do arquivo em [DllImport] pelo caminho do arquivo para o Mixed_Mode_Debugging.dll que você acabou de criar. Consulte o comentário de código para obter dicas. Substitua o espaço reservado nome de usuário.

4. Selecione Arquivo>Salvar Program.cs ou pressione Ctrl+S para salvar o arquivo.

Configurar a depuração de modo misto

1. No Gerenciador de Soluções, selecione o nó do projeto Mixed_Mode_Calling_App e escolha o ícone Propriedades ou clique com o botão direito do mouse no nó do projeto e selecione Propriedades.

2. Habilite a depuração de código nativo nas propriedades.

   Código .NET

   Selecione Depurar no painel esquerdo, selecione Abrir interface do usuário dos perfis de inicialização de depuração, marque a caixa de seleção Habilitar depuração de código nativo e, em seguida, feche a página Propriedades para salvar as mudanças.

   

   Código do .NET Framework

   No menu à esquerda, selecione Depurar. Em seguida, na seção Mecanismos do depurador, selecione a propriedade Habilitar a depuração de código nativo e feche a página de propriedades para salvar as alterações.

3. Se você estiver direcionando uma DLL x64 de um aplicativo .NET Framework, altere o destino da plataforma de Qualquer CPU para x64. Para fazer isso, talvez seja necessário selecionar Configuration Manager na lista suspensa Plataforma de Solução da barra de ferramentas de Depuração. Em seguida, se não puder alternar para x64 diretamente, crie Configuração direcionada ao x64.

Definir um ponto de interrupção e iniciar a depuração

1. No projeto C#, abra Program.cs. Defina um ponto de interrupção na linha de código a seguir clicando na margem extrema esquerda, selecionando a linha e pressionando F9 ou clicando com o botão direito do mouse na linha e selecionando Ponto de Interrupção>Inserir Ponto de Interrupção.

   int result = Multiply(7, 7);
   

   Um círculo vermelho aparece na margem esquerda em que você define o ponto de interrupção.

2. Pressione F5, selecione a seta verde na barra de ferramentas do Visual Studio ou selecione Depurar>Iniciar Depuração para iniciar a depuração.

   O depurador pausa no ponto de interrupção definido. Uma seta amarela indica onde o depurador está em pausa no momento.

Intervir e usar a depuração circular no código nativo

1. Enquanto a depuração estiver em pausa no aplicativo gerenciado, pressione F11 ou selecione Depurar>Intervir.

   O arquivo de cabeçalho nativo Mixed_Mode.h será aberto e você verá a seta amarela em que o depurador está em pausa.

   

2. Agora, você pode definir e atingir pontos de interrupção e inspecionar variáveis no código nativo ou gerenciado.

   • Passe o mouse sobre variáveis no código-fonte para ver seus valores.

   • Examine a variável e seus valores nas janelas Autos e Locais.

   • Enquanto o depurador está em pausa, você também pode usar as janelas Inspecionar e Pilha de Chamadas.

3. Pressione F11 novamente para avançar uma linha no depurador.

4. Pressione Shift+F11 ou selecione Depurar>Depuração Circular para continuar a execução e pausar novamente no aplicativo gerenciado.

5. Pressione F5 ou selecione a seta verde para continuar a depuração do aplicativo.

Parabéns! Você concluiu o tutorial sobre depuração de modo misto.

Próxima etapa

Neste tutorial, você aprendeu a depurar código nativo de um aplicativo gerenciado habilitando a depuração de modo misto. Para obter uma visão geral de outros recursos do depurador, consulte:

Introdução ao depurador