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ê aprende 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 suporta outros tipos de depuração de modo misto, como depuração Python e código nativo, e usando o depurador de script em tipos de aplicativo, como ASP.NET.

Neste tutorial, você irá:

• Criar uma DLL nativa simples
• Crie um aplicativo .NET Core ou .NET Framework simples para chamar a DLL
• Configurar depuração em modo misto
• Inicie o depurador
• Atingir ponto de interrupção na aplicação gerida
• Mergulhe no código nativo

Pré-requisitos

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

• Desenvolvimento Desktop com C++
• Desenvolvimento de desktop .NET

Se você não tiver o Visual Studio, vá para a página de 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 Instalador do Visual Studio no painel esquerdo da caixa de diálogo Visual Studio New Project. No instalador do Visual Studio, selecione as cargas de trabalho necessárias e, em seguida, 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 Modelose, 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 não conseguires ver o modelo de projeto Projeto Vazio, vá para Ferramentas>Obter ferramentas e funcionalidades..., que abre o Instalador do Visual Studio. O instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento desktop com C++ e, em seguida, escolha Modificar.

   Visual Studio cria o projeto.

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

   Se não vires todos os modelos de item, escolhe Mostrar Todos os Modelos.

3. Na caixa de diálogo Novo Item, selecione arquivo C++ (.cpp). Digite Mixed_Mode.cpp no campo Nome e 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çalhoe, em seguida, selecione Projeto>Adicionar Novo Item. Em alternativa, clique com o botão direito do rato em Ficheiros de Cabeçalho e selecione Adicionar>Novo Item.

   Se não vires todos os modelos de item, escolhe Mostrar todos os modelos de item.

6. Na caixa de diálogo Novo Item, selecione Arquivo de cabeçalho (.h). Digite Mixed_Mode.h no campo Nome e 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 os ou pressione Ctrl+Shift+S para salvar os arquivos.

Para configurar e compilar o projeto DLL:

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

2. Gerenciador de Soluções, selecione o projeto Mixed_Mode_Debugging e selecione 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 do, verifique se a de Configuração do está definida como Ative(Debug) e se a da Plataforma é a mesma definida na barra de ferramentas: x64 ou Win32 para a plataforma x86.

   Importante

   Se mudares a plataforma de x86 para x64, ou vice-versa, deves reconfigurar as propriedades da nova plataforma.

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

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

   

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

   O projeto deve ser construído sem erros.

Crie 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, em seguida, escolha Aplicativo de Console para .NET Core ou Aplicativo de Console (.NET Framework) para C#. Na caixa de diálogo exibida, escolha Avançar.

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

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

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

   Observação

   Você também pode adicionar o novo projeto gerenciado à sua solução C++ existente. Estamos criando o projeto em uma nova solução para tornar a tarefa de depuração de modo misto mais difícil.

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

2. Substitua todo o código em Program.cs com o 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 no [DllImport] pelo caminho do arquivo para o Mixed_Mode_Debugging.dll que você acabou de criar. Consulte o comentário do código para obter dicas. Certifique-se de substituir o marcador de posição do nome de utilizador .

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

Configurar depuração de modo misto

1. No Explorador de Soluções , selecione o nó do projeto Mixed_Mode_Calling_App e selecione 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 UI de perfis de lançamento de depuraçãoe, em seguida, selecione a caixa de seleção Habilitar depuração de código nativo e feche a página de propriedades para salvar as alterações.

   

   código do .NET Framework

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

3. Se estiver direcionar uma DLL x64 de uma aplicação .NET Framework, altere o alvo da plataforma de Qualquer CPU para x64. Para fazer isso, talvez seja necessário selecionar Configuration Manager a partir da lista suspensa Plataforma de Solução na barra de ferramentas Depurar. Em seguida, se não for possível alternar para x64 diretamente, crie uma Nova Configuração direcionada para 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 seguinte linha de código clicando na margem esquerda, selecionando a linha e pressionando F9ou 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 onde 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 a Depuração para iniciar a depuração.

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

Entrar e sair do código nativo

1. Enquanto a depuração estiver pausada no aplicativo gerenciado, pressione F11ou selecione Depurar>Step Into.

   O arquivo de cabeçalho nativo .h Mixed_Mode.h é aberto e você vê a seta amarela onde o depurador está pausado.

   

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

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

   • Veja as variáveis e os seus valores nas janelas Autos e Locals.

   • Enquanto o depurador está pausado, também podes usar as janelas Watch e a janela Call Stack.

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

4. Pressione Shift+F11 ou selecione Depurar>Sair 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óximo passo

Neste tutorial, você aprendeu como 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:

Primeira olhada no depurador