Tutorial: Saiba como depurar código C# usando o Visual Studio

Este artigo apresenta os recursos do depurador do Visual Studio em um passo a passo. Se você quiser uma exibição de nível superior dos recursos do depurador, consulte Primeiro examinar o depurador. Quando você depura seu aplicativo, isso geralmente significa que você está executando seu aplicativo com o depurador anexado. Quando você faz essa tarefa, o depurador fornece várias maneiras de ver o que seu código está fazendo enquanto ele é executado. Você pode percorrer seu código e examinar os valores armazenados em variáveis, definir relógios em variáveis para ver quando os valores são alterados, examinar o caminho de execução do código, ver se um branch de código está em execução e assim por diante. Se este exercício for a primeira vez que você está tentando depurar código, você pode querer ler depuração para iniciantes absolutos antes de passar por este artigo.

Embora o aplicativo de demonstração seja C#, a maioria dos recursos é aplicável a C++, Visual Basic, F#, Python, JavaScript e outras linguagens compatíveis com o Visual Studio (F# não dá suporte a Editar e continuar. F# e JavaScript não dão suporte à janela de Autos ). As capturas de tela estão em C#.

Neste tutorial, você irá:

• Inicie o depurador e atinja pontos de interrupção.
• Aprender os comandos para percorrer o código no depurador
• Inspecionar variáveis em dicas de dados e janelas do depurador
• Examinar a pilha de chamadas

Pré-requisitos

Você deve ter o Visual Studio 2022 instalado e o workload do .NET para desenvolvimento de aplicativos de área de trabalho.

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

Se você já tiver o Visual Studio, mas a carga de trabalho de desenvolvimento da área de trabalho do .NET não estiver instalada, vá para Ferramentas>Obter Ferramentas e Recursos..., que inicia o Instalador do Visual Studio. No Instalador do Visual Studio, selecione o workload de desenvolvimento de área de trabalho do .NET e escolha Modificar.

Criar um projeto

Primeiro, você cria um projeto de aplicativo de console do .NET Core. O tipo de projeto vem com todos os arquivos de modelo necessários, antes mesmo de adicionar qualquer coisa!

1. Abra o Visual Studio. Se a janela inicial não estiver aberta, selecioneJanela Iniciar>.

2. Na janela inicial, selecione Criar um novo projeto.

3. Na janela Criar um novo projeto , insira o console na caixa de pesquisa. Em seguida, escolha C# na lista De idiomas e escolha o Windows na lista plataforma.

   Depois de aplicar os filtros de linguagem e plataforma, escolha o modelo de Aplicativo de Console e selecione Avançar.

   

   Observação

   Se você não vir o modelo de Aplicativo de Console , poderá instalá-lo na janela Criar um novo projeto . Na mensagem Não encontrar o que você está procurando? Escolha o link Instalar mais ferramentas e recursos . Em seguida, no Instalador do Visual Studio, escolha a carga de trabalho de desenvolvimento da área de trabalho do .NET .

4. Na janela Configurar seu novo projeto , insira GetStartedDebugging na caixa de nome do Projeto . Em seguida, selecione Avançar.

5. Na janela Informações adicionais , verifique se o .NET 8.0 está selecionado no menu suspenso da Estrutura e selecione Criar.

O Visual Studio abre seu novo projeto.

Criar o aplicativo

Em Program.cs, substitua todo o código padrão pelo seguinte código:

using System;

class ArrayExample
{
   static void Main()
   {
      char[] letters = { 'f', 'r', 'e', 'd', ' ', 's', 'm', 'i', 't', 'h'};
      string name = "";
      int[] a = new int[10];
      for (int i = 0; i < letters.Length; i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
      Console.ReadKey();
   }

   static void SendMessage(string name, int msg)
   {
      Console.WriteLine("Hello, " + name + "! Count to " + msg);
   }
}

Inicie o depurador!

Principalmente, usamos atalhos de teclado aqui, porque é uma maneira rápida de executar comandos do debugger. Comandos equivalentes, como comandos de menu ou barra de ferramentas, também são mencionados.

1. Para iniciar o depurador, selecione F5 ou escolha o botão Depurar Destino na barra de ferramentas Padrão ou escolha o botão Iniciar Depuração na barra de ferramentas Depurar ou escolha Depurar>Iniciar Depuração na barra de menus.

   

   F5 inicia o aplicativo com o depurador conectado ao processo do aplicativo. Como não fizemos nada especial para examinar o código, o aplicativo é executado até a conclusão e você vê a saída do console.

   Hello, f! Count to 1
   Hello, fr! Count to 2
   Hello, fre! Count to 3
   Hello, fred! Count to 4
   Hello, fred ! Count to 5
   Hello, fred s! Count to 6
   Hello, fred sm! Count to 7
   Hello, fred smi! Count to 8
   Hello, fred smit! Count to 9
   Hello, fred smith! Count to 10
   

2. Para interromper o depurador, selecione Shift+F5 ou escolha o botão Parar Depuração na barra de ferramentas de Depuração ou escolha Depurar>Parar Depuração na barra de menus.

   

3. Na janela do console, selecione qualquer chave para fechar a janela do console.

Definir um ponto de interrupção e iniciar o depurador

1. for No loop da Main função, defina um ponto de interrupção clicando na margem esquerda na seguinte linha de código:

   name += letters[i];

   Um círculo vermelho é exibido onde você define o ponto de interrupção.

   

   Pontos de interrupção são um recurso essencial da depuração confiável. Você pode definir pontos de interrupção em que deseja que o Visual Studio pause o código em execução para que possa examinar os valores das variáveis ou o comportamento da memória ou saber se um branch de código está sendo executado ou não.

2. Para iniciar a depuração, selecione F5 ou escolha o botão Depurar Destino na barra de ferramentas Standard ou escolha o botão Iniciar Depuração na barra de ferramentas Depurar ou escolha Depurar>Iniciar Depuração na barra de menus. O aplicativo é iniciado e o depurador é executado na linha de código em que você definiu o ponto de interrupção.

   

   A seta amarela aponta para a instrução na qual o depurador fez uma pausa. A execução do aplicativo é pausada no mesmo ponto, com a instrução ainda não executada.

   Quando o aplicativo não está em execução, o F5 inicia o depurador, que executa o aplicativo até chegar ao primeiro ponto de interrupção. Se o aplicativo estiver em pausa em um ponto de interrupção, f5 continuará executando o aplicativo até chegar ao próximo ponto de interrupção.

   Pontos de interrupção são um recurso útil quando você conhece a linha ou a seção de código que deseja examinar em detalhes. Para obter mais informações sobre os diferentes tipos de pontos de interrupção que você pode definir, como pontos de interrupção condicionais, consulte Como usar pontos de interrupção.

Navegar pelo código e inspecionar dados usando dicas de dados

1. Enquanto a execução de código é pausada na name += letters[i] instrução, passe o mouse sobre a letters variável para ver uma dica de dados mostrando o tamanho da matriz e o tipo de elemento. char[10]

   Observação

   Um dos recursos mais úteis do depurador é a capacidade de inspecionar uma variável. Muitas vezes, quando você está tentando depurar um problema, você está tentando descobrir se as variáveis têm valores que você espera em um determinado momento. Exibir dicas de dados é uma boa maneira de verificar isso.

2. Expanda a letters variável para exibir todos os seus elementos de matriz e seus valores.

   

3. Passe o mouse sobre a name variável para ver seu valor atual, que é uma cadeia de caracteres vazia.

4. Para avançar o depurador para a próxima instrução, selecione F10 ou escolha o botão Passo a passo na barra de ferramentas Depurar ou escolha Depurar>Passo a Passo na barra de menus. Selecione F10 mais duas vezes para passar da chamada do SendMessage método.

   F10 avança o depurador sem entrar em funções ou métodos, embora seu código ainda seja executado. Dessa forma, pulamos a depuração do código no SendMessage método, no qual não estamos interessados no momento.

5. Para iterar pelo for loop algumas vezes, selecione F10 repetidamente. Durante cada iteração do loop, pause no ponto de interrupção e passe o mouse sobre a variável name para verificar seu valor na dica de dados.

   

   O valor da variável muda com cada iteração do for loop, mostrando valores de f, em seguida fr, e freassim por diante. Para avançar o depurador pelo loop mais rapidamente, selecione F5, o que avança para o ponto de interrupção em vez da próxima linha de código.

6. Enquanto a execução do código estiver em pausa no loop do método Main, selecione F11, ou escolha o botão Avançar na barra de ferramentas Depurar, ou escolha Depurar>Avançar na barra de menus, até chegar à chamada do método SendMessage.

   O depurador deve estar pausado nessa linha de código:

   SendMessage(name, a[i]);

7. Para entrar no SendMessage método, selecione F11 novamente.

   O ponteiro amarelo avança para o SendMessage método.

   

   F11 ajuda você a examinar o fluxo de execução do código com mais profundidade. Para entrar em um método a partir de uma chamada de método, selecione F11. Por padrão, o depurador ignora a entrada em métodos nonuser. Para saber mais sobre a depuração de código nonuser, consulte Just My Code.

   Depois de concluir a depuração do método SendMessage, você estará pronto para retornar ao loop for do método main.

8. Para sair do SendMessage método, selecione Shift+F11, ou escolha o botão Sair do Método na barra de ferramentas de Depuração, ou escolha Depurar>Sair do Método na barra de menus.

   Step Out retoma a execução do aplicativo e avança o depurador até que o método ou função atual retorne.

   Você vê o ponteiro amarelo de volta no loop do método for, pausado na chamada do método SendMessage. Para obter mais informações sobre diferentes maneiras de percorrer seu código, consulte Navegar código no depurador.

Navegar pelo código usando Executar para Clicar

1. Selecione F5 para avançar para o ponto de interrupção novamente.

2. No editor de código, passe o mouse sobre a Console.WriteLine chamada de método no SendMessage método até que o botão Executar para Clicar seja exibido. A dica de ferramenta do botão mostra "Executar até aqui".

   

3. Escolha o botão Executar para Clicar . Como alternativa, com o cursor na instrução Console.WriteLine , selecione Ctrl+F10. Ou clique com o botão direito do mouse na chamada do Console.WriteLine método e escolha Executar para Cursor no menu de contexto.

   O depurador avança para a chamada do método Console.WriteLine.

   Usar o botão Executar para Clicar é semelhante à configuração de um ponto de interrupção temporário e é útil para se locomover rapidamente em uma região visível do código do aplicativo em um arquivo aberto.

Reinicie seu aplicativo rapidamente

Para executar novamente seu aplicativo desde o início no depurador, selecione Ctrl+Shift+F5 ou escolha o botão Reiniciar na barra de ferramentas Depurar ou escolha Depurar Reinicialização> na barra de menus.

Reinicie o depurador e reinicie-o em uma etapa. Quando o depurador é reiniciado, ele vai até o primeiro ponto de interrupção, que é o ponto de interrupção definido anteriormente dentro do for loop, e então pausa.

Inspecionar variáveis com as janelas Autos e Locais

As janelas Autos e Locais mostram valores de variáveis durante a depuração. As janelas só ficam disponíveis durante uma sessão de depuração. A janela Autos mostra variáveis usadas na linha atual em que o depurador está e na linha anterior. A janela Locais mostra variáveis definidas no escopo local, que geralmente é a função ou o método atual.

1. Enquanto o depurador está em pausa, exiba a janela Autos na parte inferior do editor de código.

   Se a janela Autos estiver fechada, selecione Ctrl+D, A ou escolha Depurar>Windows>Autos na barra de menus.

2. Com o depurador ainda em pausa, exiba a janela Locais, em uma guia ao lado da janela Autos.

   Se a janela Locais estiver fechada, selecione Ctrl+D, L ou escolha Depurar>Windows>Locais.

3. Na janela Locais , expanda a letters variável para ver seus elementos de matriz e seus valores.

   

Para obter mais informações sobre as janelas Autos e Locais , consulte Inspecionar variáveis nas janelas Autos e Locais.

Definir uma inspeção

Você pode especificar uma variável ou expressão que deseja monitorar ao depurar o código, adicionando-a à janela Watch.

1. Enquanto o depurador está pausado, clique com o botão direito do mouse na variável name e escolha Adicionar Monitoramento.

   A janela Watch é aberta por padrão na parte inferior do editor de código.

2. Agora que você definiu um relógio na variável, percorra seu name código para ver o valor da alteração da name variável com cada for iteração de loop.

   Ao contrário das outras janelas variáveis, a janela Inspeção sempre mostra as variáveis que você está observando. Variáveis fora do escopo são exibidas como indisponíveis.

Para obter mais informações sobre a janela Observação, consulte Variáveis de observação com janelas de observação.

Examinar a pilha de chamadas

A Pilha de Chamadas pode ajudá-lo a entender o fluxo de execução do seu aplicativo, mostrando a ordem em que métodos e funções estão sendo chamados.

1. Enquanto o depurador está pausado no for loop, exiba a janela Pilha de Chamadas, que se abre por padrão no painel inferior direito do editor de código.

   Se a janela Pilha de Chamadas estiver fechada, selecione Ctrl+D, C ou escolha Depurar>Windows>Pilha de Chamadas na barra de menus.

   Na janela Pilha de Chamadas , você verá o ponteiro amarelo no método atual Main .

2. No método SendMessage, selecione F11 algumas vezes até ver o depurador pausar.

   A linha superior da janela Pilha de Chamadas mostra a função atual, que é o método SendMessage. A segunda linha mostra que o SendMessage método foi chamado do Main método.

   

   Observação

   A janela Pilha de Chamadas é semelhante à perspectiva de depuração em alguns IDEs, como o Eclipse.

   Na janela Pilha de Chamadas, você pode clicar duas vezes em uma linha de código para acessar esse código-fonte, o que altera o escopo atual sob inspeção pelo depurador. Essa ação não avança o depurador.

   Você também pode usar os menus acessados ao clicar com o botão direito do mouse na janela Pilha de Chamadas para fazer outras coisas. Por exemplo, você pode inserir pontos de interrupção em funções especificadas, avançar o depurador usando Executar para Cursor ou ir para o código-fonte.

Para obter mais informações sobre a Pilha de Chamadas, consulte Como examinar a pilha de chamadas.

Próximas etapas

Neste tutorial, você aprendeu a iniciar o depurador, percorrer o código e inspecionar variáveis. Talvez você queira obter uma visão de alto nível dos recursos do depurador, juntamente com links para mais informações.

Introdução ao depurador