Tutorial: Aprenda a depurar código C# usando o Visual Studio

Este artigo apresenta os recursos do depurador do Visual Studio em um passo a passo. Se pretender uma visão mais abrangente dos recursos do depurador, consulte Primeira olhada no depurador. Quando depura a sua aplicação, isso geralmente significa que está a executar a sua aplicação com o depurador ligado. Quando você faz essa tarefa, o depurador fornece muitas maneiras de ver o que seu código está fazendo enquanto é executado. Você pode percorrer seu código e examinar os valores armazenados em variáveis, você pode definir inspeções em variáveis para ver quando os valores mudam, você pode examinar o caminho de execução do seu código, ver se uma ramificação de código está em execução e assim por diante. Se este exercício é a primeira vez que tentas depurar código, convém ler Depuração para iniciantes absolutos antes de leres 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 suportadas pelo Visual Studio (F# não suporta Edit-and-continue. F# e JavaScript não suportam a janela Autos). As capturas de tela estão em C#.

Neste tutorial, você irá:

• Inicie o depurador e acerte os pontos de interrupção.
• Aprenda instruções para passar pelo código no depurador
• Inspecionar variáveis em informações de dados e janelas do depurador
• Examine a pilha de chamadas

Pré-requisitos

Você deve ter o Visual Studio 2022 instalado e o de trabalho de desenvolvimento de desktop .NET.

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

Se você já tiver o Visual Studio, mas a de trabalho de desenvolvimento da área de trabalho .NET não estiver instalada, vá para Ferramentas>Obter Ferramentas e Recursos..., que inicia o Visual Studio Installer. No instalador do Visual Studio, escolha a carga de trabalho de de desenvolvimento da área de trabalho .NET e, em seguida, 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 que você precisa, antes mesmo de adicionar qualquer coisa!

1. Abra o Visual Studio. Se a janela iniciar não estiver aberta, selecione Ficheiro>Janela iniciar.

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

3. Na janela Criar um novo projeto, digite console na caixa de pesquisa. Em seguida, escolha C# na lista Idioma e, em seguida, escolha Windows na lista Plataforma.

   Depois de aplicar os filtros de idioma e plataforma, escolha o modelo Aplicação de Consola e depois selecione Avançar.

   

   Observação

   Se não vir o modelo Aplicação Consola, pode instalá-lo a partir da janela Criar um novo projeto. Na mensagem "Não encontra o que procura?", 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 .NET .

4. Na janela Configurar o novo projeto, digite GetStartedDebugging na caixa Nome do Projeto. Em seguida, selecione Avançar.

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

O Visual Studio abre seu novo projeto.

Criar o aplicativo

No 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, utilizamos atalhos de teclado aqui, pois é uma maneira rápida de executar comandos do depurador. Comandos equivalentes, como comandos de barra de ferramentas ou de menu, também são mencionados.

1. Para iniciar o depurador, selecione F5, ou escolha o botão Debug Target na barra de ferramentas Standard, ou escolha o botão Start Debugging na barra de ferramentas Debug, ou escolha Depurar>Start Debugging na barra de menus.

   

   F5 inicia a aplicação com o depurador ligado ao processo da aplicação. Como não fizemos nada de especial para examinar o código, a aplicação é executada até ser concluída 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 parar o depurador, selecione Shift+F5, ou clique no botão Parar Depuração na barra de ferramentas Depurar, ou escolha Depurar>Parar Depuração na barra de menus.

   

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

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

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

   name += letters[i];

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

   

   Os pontos de interrupção são uma característica fundamental do debugging confiável. Você pode definir pontos de interrupção onde deseja que o Visual Studio pause seu código em execução para que você possa examinar os valores das variáveis ou o comportamento da memória, ou saber se uma ramificação do código está sendo executada ou não.

2. Para iniciar a depuração, selecione F5, ou escolha o botão Alvo de Depuração na barra de ferramentas Padrão, ou escolha o botão Iniciar Depuração na barra de ferramentas de Depuração, ou escolha Depurar>Iniciar Depuração na barra de menus. O aplicativo é iniciado e o depurador é executado até a linha de código onde você define o ponto de interrupção.

   

   A seta amarela aponta para a declaração em que 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, F5 inicia o depurador, que executa o aplicativo até atingir o primeiro ponto de interrupção. Se o aplicativo estiver pausado em um ponto de interrupção, F5 continuará executando o aplicativo até atingir o próximo ponto de interrupção.

   Os pontos de interrupção são um recurso útil quando você conhece a linha ou 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 Usando pontos de interrupção.

Navegar no código e inspecionar dados usando dicas sobre dados

1. Enquanto a execução de código é pausada na instrução name += letters[i], passe o mouse sobre a variável letters 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 é sua 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. Verificar dicas de dados é uma excelente maneira de confirmar isso.

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

   

3. Passe o cursor sobre a variável name 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 Passar por Cima na barra de ferramentas Depurar, ou escolha Depurar>Passar por Cima na barra de menus. Selecione F10 mais duas vezes para passar pela chamada de método SendMessage.

   F10 avança o depurador sem entrar em funções ou métodos, embora o seu código ainda seja executado. Dessa forma, evitámos depurar o código no método SendMessage, que não nos interessa no momento.

5. Para iterar pelo loop de for várias vezes, selecione F10 repetidamente. Durante cada iteração de loop, pause no ponto de interrupção e passe o cursor do rato sobre a variável name para verificar seu valor no tooltip.

   

   O valor da variável muda a cada iteração do loop de for, mostrando valores de f, depois fr, depois free assim por diante. Para avançar o depurador pelo loop mais rapidamente, selecione F5, que avança para o ponto de interrupção em vez da próxima instrução.

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

   O depurador deverá ser pausado nesta linha de código:

   SendMessage(name, a[i]);

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

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

   

   F11 ajuda você a examinar o fluxo de execução do seu 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 os métodos não pertencentes ao utilizador. Para saber mais sobre como depurar código de não-usuário, consulte Just My Code.

   Depois de concluíres o debugging do método SendMessage, estás pronto para retornar ao loop de for do método main.

8. Para sair do método SendMessage, selecione Shift+F11, ou escolha o botão Sair na barra de ferramentas de Depuração, ou escolha Depurar>Sair 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 de for do método Main, pausado na chamada do método SendMessage. Para obter mais informações sobre diferentes maneiras de percorrer o seu código, consulte Navegação de código no depurador.

Navegue 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ódigos, coloque o cursor sobre a chamada do método Console.WriteLine no método SendMessage até que o botão Executar com clique apareça. 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 método Console.WriteLine e escolha Executar para do cursor no menu de contexto.

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

   Usar o botão Executar para Clicar é semelhante a definir um ponto de interrupção temporário e é eficaz para navegar rapidamente dentro de uma região visível do código da sua aplicação num ficheiro aberto.

Reinicie seu aplicativo rapidamente

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

Reiniciar pára o depurador e depois reinicia-o, num único passo. Quando o depurador é reiniciado, ele corre até o primeiro ponto-de-interrupção, que é o ponto-de-interrupção definido anteriormente dentro do for loop, e, em seguida, pausa.

Inspecione variáveis com as janelas Autos e Locais

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

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

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

2. Com o depurador ainda em pausa, visualize a janela Locals, num separador ao lado da janela Autos.

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

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

   

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

Ajustar um relógio

Você pode especificar uma variável ou uma expressão que deseja acompanhar enquanto percorre o código, adicionando-a à janela Inspeção.

1. Enquanto o depurador estiver pausado, clique com o botão direito do rato na variável name e escolha Adicionar Observação.

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

2. Agora que definiu uma monitorização na variável name, percorra o seu código para ver o valor da variável name alterar-se a cada iteração do ciclo for.

   Ao contrário das outras janelas de variáveis, a janela Watch mostra sempre as variáveis que está a observar. As variáveis que estão fora do escopo são exibidas como indisponíveis.

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

Examine a pilha de chamadas

A pilha de chamadas pode ajudá-lo a entender a sequência de execução da sua aplicação, mostrando a ordem na qual os métodos e funções estão a ser chamados.

1. Enquanto o depurador está pausado no loop for, exiba a janela Call Stack, que é aberta por padrão no painel inferior direito do editor de código.

   Se a janela Call Stack estiver fechada, selecione Ctrl+D, Cou escolha Depurar>Windows>Call Stack na barra de menus.

   Na janela Call Stack, você vê o ponteiro amarelo no método Main atual.

2. Selecione F11 algumas vezes até ver o depurador pausar no método SendMessage.

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

   

   Observação

   A janela Call Stack é semelhante à perspetiva Debug em alguns IDEs, como o Eclipse.

   Na janela Call Stack, podes fazer duplo clique numa linha de código para ir para esse código-fonte, o que altera o escopo atual que está a ser inspecionado pelo depurador. Esta ação não avança o depurador.

   Pode também usar os menus do botão direito na janela da pilha de chamadas para fazer outras coisas. Por exemplo, pode-se inserir pontos de interrupção em funções especificadas, avançar o depurador usando Executar até ao Cursorou ir para o código-fonte.

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

Próximos passos

Neste tutorial, você aprendeu como iniciar o depurador, percorrer o código e inspecionar variáveis. Você pode querer obter uma visão de alto nível dos recursos do depurador, assim como links para mais informações.

Primeira olhada no depurador