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 Primeiro olhar sobre o depurador. Quando se depura o seu aplicativo, normalmente significa que está a executar o seu aplicativo com o depurador anexado. 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 é o teu primeiro exercício de depuração de código, convém ler Depuração para iniciantes absolutos antes de ler 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 atinja os pontos de interrupção.
• Aprenda comandos para percorrer o código no depurador
• Inspecionar variáveis em dicas 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 desenvolvimento de á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 de início não estiver aberta, selecione Arquivo>Janela de Início.

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 Aplicativo de Console e selecione Avançar.

   

   Observação

   Se não vir o modelo de da 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 funcionalidades. Em seguida, no instalador do Visual Studio, escolha a carga de trabalho de desenvolvimento de desktop .NET .

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

5. Na janela de Informações Adicionais , assegure-se de que o .NET 8.0 esteja selecionado no menu suspenso de Framework , e depois 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!

Na maioria das vezes, usamos atalhos de teclado aqui, porque é uma forma rápida de executar comandos do depurador. Comandos equivalentes, como comandos de barra de ferramentas ou de menu, também são indicados.

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

   

   F5 inicia a aplicação com o depurador anexado ao processo da aplicação. Como não fizemos nada de especial para examinar o código, a aplicação é executada até ao fim e vê-se 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 escolha o 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 essencial da depuração 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 F5ou escolha o botão Destino de Depuração na barra de ferramentas Padrão, ou escolha o botão Iniciar Depuração na barra de ferramentas 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 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, 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 utilizando sugestões de 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. Visualizar dicas de dados é uma boa maneira de verificar 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 Step Over na barra de ferramentas Depurar ou escolha Depurar>Step Over 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, ignoramos a depuração do código no método SendMessage, que não nos interessa no momento.

5. Para iterar pelo loop de for algumas vezes, selecione F10 repetidamente. Durante cada iteração de 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 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 seu ponto de interrupção em vez da próxima instrução.

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

   O depurador deverá estar 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 evita entrar em métodos não pertencentes ao utilizador. Para saber mais sobre como depurar código de não-usuário, consulte Just My Code.

   Após concluir a depuração do método SendMessage, estará pronto para regressar ao ciclo de for do método main.

8. Para sair do método SendMessage, selecione Shift+F11, escolha o botão Sair na barra de ferramentas Depurar 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ê novamente o ponteiro amarelo no loop 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 Navegar no código com o 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, passe o rato 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 para o 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 até o 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 é útil 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 interrompe o depurador e depois reinicia-o, num só passo. Quando o depurador é reiniciado, ele é executado até o primeiro ponto de interrupção, que é o ponto de interrupção definido anteriormente dentro do loop de for e, em seguida, pausa.

Inspecione variáveis com as janelas Autos e Locais

As janelas Autos e Locals mostram valores 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 que a precede. 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 pausado, veja a janela Locais numa aba ao lado da janela Automáticos.

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

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

   

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

Ajustar o relógio / Definir um vigia

Você pode especificar uma variável ou uma expressão na qual deseja ficar de olho ao percorrer 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 à Monitorização.

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

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

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

Para obter 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

O Pilha de Chamadas pode ajudá-lo a entender o fluxo de execução do seu aplicativo, mostrando a ordem na qual os métodos e funções são chamados.

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

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

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

2. Selecione F11 várias vezes até que veja a pausa do depurador 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, pode-se clicar duas vezes numa linha de código para ir para o código-fonte correspondente, isso altera o escopo atual em inspeção pelo depurador. Esta ação não avança o depurador.

   Você também pode usar os menus de clique com o botão direito na janela de 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 Cursorou ir para o código-fonte.

Para obter 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 ter uma visão de alto nível dos recursos do depurador, juntamente com links para mais informações.

Primeira olhada no depurador