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

Aplica-se a:Visual Studio Visual Studio para Mac Visual Studio Code

Este artigo apresenta os recursos do depurador do Visual Studio passo a passo. Caso deseje obter uma exibição de nível superior das funcionalidades do depurador, confira Introdução ao depurador. Quando você depura seu aplicativo, isso normalmente significa executar o aplicativo com o depurador anexado. Quando você faz isso, o depurador fornece várias maneiras de mostrar o que o código está fazendo enquanto é executado. Você pode percorrer o código e examinar os valores armazenados em variáveis, definir inspeções em variáveis para ver quando os valores mudam, 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 esta for sua primeira tentativa de depurar um código, é interessante ler Depuração para iniciantes antes continuar neste artigo.

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

Neste tutorial, você irá:

• Iniciar o depurador e atingir os 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ê precisa do Visual Studio 2022 instalado e a carga de trabalho Desenvolvimento de área de trabalho do .NET.

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

Se você já tem o Visual Studio, mas a carga de trabalho Desenvolvimento de área de trabalho do .NET não estiver instalada, acesse Ferramentas>Obter Ferramentas e Recursos..., que inicia o Instalador do Visual Studio. No Instalador do Visual Studio, escolha a carga de trabalho Desenvolvimento de área de trabalho do .NET e selecione Modificar.

Criar um projeto

Primeiro, você vai criar um projeto de aplicativo de console do .NET Core. O tipo de projeto inclui todos os arquivos de modelo que você precisará, mesmo sem adicionar nada!

1. Abra o Visual Studio. Se a janela inicial não estiver aberta, escolha Arquivo>Janela Inicial.

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

3. Na janela Criar um novo projeto, insira ou digite console na caixa de pesquisa. Em seguida, escolha C# na lista Linguagem de programação e, em seguida, escolha Windows na lista Plataforma.

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

   

   Observação

   Se não vir o modelo Aplicativo de Console, instale-o por meio da janela Criar um novo projeto. Na mensagem Não encontrou o que precisa?, escolha o link Instalar mais ferramentas e recursos. Em seguida, no Instalador do Visual Studio, escolha a carga de trabalho Desenvolvimento de área de trabalho do .NET.

4. Na janela Configurar seu novo projeto, digite ou insira GetStartedDebugging na caixa Nome do projeto. Em seguida, escolha Avançar.

5. Na janela Informações adicionais, verifique se o .NET 6.0 (suporte a longo prazo) está selecionado no menu suspenso Estrutura e escolha Criar.

   O Visual Studio abre seu novo projeto.

Criar o aplicativo

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

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 da barra de ferramentas ou do menu, também são indicados.

1. Para iniciar o depurador, selecione F5 ou 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 Depurar ou escolha Depurar>Iniciar Depuração na barra de menus.

   

   A tecla F5 inicia o aplicativo com o depurador anexado 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 no 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 Depurar ou escolha Depurar>Parar Depuração na barra de menus.

   

3. Na janela do console, selecione qualquer tecla para fechá-la.

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 da seguinte linha de código:

   name += letters[i];

   Aparece um círculo vermelho no qual você definiu o ponto de interrupção.

   

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

2. Para iniciar a depuração, selecione F5 ou 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 Depurar ou escolha Depurar>Iniciar Depuração na barra de menus. O aplicativo é iniciado e o depurador executa até a 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 está pausada no mesmo ponto, com a instrução ainda não executada.

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

   Os pontos de interrupção são recursos úteis quando você sabe a linha ou a seção de código que deseja examinar em detalhes. Para saber mais sobre os diferentes tipos de pontos de interrupção que você pode definir, como pontos de interrupção condicionais, confira Como usar pontos de interrupção.

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

1. Enquanto pausado na instrução name += letters[i], 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 é sua capacidade de inspecionar uma variável. Muitas vezes, ao tentar depurar um problema, você está tentando descobrir se as variáveis têm valores que você espera em um determinado momento. Ver dicas de dados é uma boa maneira de verificar isso.

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

   

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

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

   O F10 avança o depurador sem intervir na função ou nos métodos, embora os respectivos códigos ainda sejam executados. Dessa forma, pulamos a depuração do código no método SendMessage, no qual não temos interesse no momento.

5. Para iterar no loop 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 o valor dela na dica de dados.

   

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

6. Enquanto estiver pausado no loop for do método Main, selecione F11 ou escolha o botão Intervir na barra de ferramentas Depurar ou escolha Depurar>Intervir na barra de menus até chegar à chamada de método SendMessage.

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

   SendMessage(name, a[i]);

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

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

   

   O F11 ajuda você a examinar mais detalhadamente o fluxo de execução do código. Para intervir em um método de uma chamada de método, selecione F11. Por padrão, o depurador ignora a intervenção em métodos que não são de usuário. Para saber mais sobre a depuração de código que não é de usuário, confira Apenas Meu Código.

   Depois de terminar de depurar o método SendMessage, você estará pronto para retornar ao loop 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 Depurar ou escolha Depurar>Sair na barra de menus.

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

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

Navegar usando Executar até o Clique

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

2. No editor de código, passe o mouse sobre a chamada de método Console.WriteLine no método SendMessage até que o botão Executar até o Clique apareça à esquerda. A dica de ferramenta para o botão mostra "Realizar a execução até aqui".

   

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

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

   O uso do botão Executar até o Clique é 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 o aplicativo rapidamente

Para executar novamente o 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>Reiniciar na barra de menus.

O comando Reiniciar interrompe o depurador e, em seguida, reinicia-o em apenas uma etapa. Quando o depurador for reiniciado, ele vai executar até o primeiro ponto de interrupção, que aquele que você definiu anteriormente dentro do loop for e, em seguida, pausará.

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 Locals mostra as variáveis definidas no escopo local, que geralmente é o método ou a função atual.

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

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

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

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

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

   

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

Definir uma inspeção

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 está em pausa, clique com o botão direito do mouse na variável name e escolha Adicionar Inspeção.

   A janela Inspeção abre-se por padrão na parte inferior do editor de código.

2. Agora que você definiu uma inspeção na variável name, percorra o código para ver o valor da variável name mudar com cada iteração do loop for.

   Ao contrário das outras janelas de variáveis, a janela Inspeção sempre mostra as variáveis que você está inspecionando, embora elas fiquem esmaecidas quando estão fora do escopo.

Para obter mais informações sobre a janela Inspeção, confira Inspecionar variáveis com Janelas de inspeção.

Examinar a pilha de chamadas

A Pilha de Chamadas pode ajudar você a entender o fluxo de execução do aplicativo, mostrando a ordem em que métodos e funções estão sendo chamados.

1. Enquanto o depurador estiver pausado no loop for, veja a janela Pilha de Chamadas que é aberta 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>Janelas>Pilha de Chamadas na barra de menus.

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

2. Selecione F11 algumas vezes até que o depurador seja pausado no método SendMessage.

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

   

   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 vai alterar o escopo atual que está sendo inspecionado 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 específicas, avançar o depurador usando Executar até o Cursor ou acessar o código-fonte.

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

Alterar o fluxo de execução

Você pode mover o ponteiro de execução para alterar o fluxo do aplicativo durante a depuração.

1. Com o depurador pausado na chamada de método SendMessage no loop for, selecione F11 três vezes para intervir no método SendMessage e passar pelo método Console.WriteLine depois de executá-lo.

   Agora o depurador está em pausa na chave de fechamento final do método SendMessage.

2. Use o mouse para pegar a seta amarela ou o ponteiro de execução (na margem esquerda) e arraste o ponteiro uma linha para cima.

   Agora o depurador está de volta à instrução Console.WriteLine.

3. Selecione F11.

   O depurador executa novamente o método Console.WriteLine e você verá uma linha duplicada na saída da janela do console.

4. Selecione F5 para continuar a execução do aplicativo.

Alterando o fluxo de execução, você pode fazer coisas como testar caminhos de execução de código diferentes ou executar novamente o código sem reiniciar o depurador.

Aviso

Use esse recurso com cuidado. Você verá um aviso na dica de ferramenta do ponteiro de execução sobre a possibilidade de consequências indesejadas. Você também pode ver outros avisos. A movimentação do ponteiro de execução não pode reverter seu aplicativo para um estado anterior.

Para obter mais informações sobre como alterar o fluxo de execução, confira Mover o ponteiro para alterar o fluxo de execução.

Parabéns por concluir este tutorial.

Próximas etapas

Neste tutorial, você aprendeu como iniciar o depurador, percorrer o código e inspecionar variáveis. Pode ser interessante ter uma visão geral de alto nível dos recursos do depurador com links para mais informações.

Introdução ao depurador