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

  • Artigo

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 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 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 este exercício for a primeira vez que você tentou depurar um código, talvez você queira ler Depuração para iniciantes absolutos antes de continuar neste 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 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.

Você deve ter o Visual Studio 2019 instalado e a carga de trabalho Desenvolvimento multiplataforma do .NET Core.

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

Caso precise instalar a carga de trabalho, mas já tiver o Visual Studio, acesse Ferramentas>Obter Ferramentas e Funcionalidades..., que abre o Instalador do Visual Studio. O Instalador do Visual Studio é iniciado. Escolha a carga de trabalho Desenvolvimento multiplaforma do .NET Core e selecione Modificar.

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ê 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 você adicionar alguma coisa!

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

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

  1. Na janela Criar um novo projeto, insira 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 de Aplicativo de Console para .NET Core e selecione Avançar.

    Screenshot of the C# template for the Console App.

    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 de desenvolvimento multiplataforma do .NET Core.

  2. Na janela Configurar seu novo projeto, insira GetStartedDebugging na caixa Nome do projeto. Em seguida, selecione Avançar.

  3. Selecione a estrutura de destino recomendada (suporte ao .NET 8.0 ou a longo prazo) e selecione Criar.

  1. Na janela Criar um novo projeto, insira 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 de Aplicativo de Console e selecione Avançar.

    Screenshot of the 'Console Application' template in the 'Create a new project' window of Visual Studio 2022.

    Observação

    Se você não vir o modelo de Aplicativo de Console, poderá instalá-lo na janela Criar um 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.

  2. Na janela Configurar seu novo projeto, insira GetStartedDebugging na caixa Nome do projeto. Em seguida, selecione Avançar.

  3. 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

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.

  1. Pressione F5 (Depurar >Iniciar depuração) ou o botão Iniciar depuraçãoImage of the Start Debugging button. na barra de ferramentas Depurar.

    F5 inicia o aplicativo com o depurador anexado ao processo do aplicativo, mas nós ainda não fizemos nada de especial para examinar o código. Portanto, o aplicativo apenas carrega e você vê essa 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

    Neste tutorial, você examinará melhor este aplicativo usando o depurador e verá os recursos do depurador.

  2. Pare o depurador pressionando o botão de parada vermelha (Shift + F5). Image of the Stop Debugging button.

  3. Na janela do console, pressione uma tecla para fechá-la.

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.

    Screenshot of the Debug Target button in the Standard toolbar of Visual Studio 2022.

    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.

    Screenshot of the Stop debugging button in the Debug toolbar of Visual Studio 2022.

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

    name += letters[i];

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

    Pontos de interrupção são um dos recursos mais básicos e essenciais de uma depuração confiável. Um ponto de interrupção indica quando o Visual Studio deve suspender o código em execução para que você possa examinar os valores das variáveis ou o comportamento de memória ou se uma ramificação de código está sendo executada ou não.

  2. Pressione F5 ou o botão Iniciar Depuração. Screenshot of the Start Debugging button. O aplicativo é iniciado e o depurador é executado na linha de código em que você define o ponto de interrupção.

    Set and hit a breakpoint

    A seta amarela representa a instrução na qual o depurador fez uma pausa, que também suspende a execução do aplicativo no mesmo ponto (essa instrução ainda não foi executada).

    Se o aplicativo ainda não estiver em execução, F5 inicia o depurador e é interrompido no primeiro ponto de interrupção. Caso contrário, F5 continuará executando o aplicativo até o próximo ponto de interrupção.

    Os pontos de interrupção são um recurso útil quando você sabe qual linha ou seção de código deseja examinar em detalhes. Para obter informações 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.

  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];

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

    Screenshot of a breakpoint in Visual Studio 2022.

    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.

    Screenshot showing a breakpoint in the code editor of Visual Studio 2022, with code execution paused at the breakpoint.

    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 está em execuçã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, 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.

Geralmente, usamos atalhos de teclado aqui porque essa é uma boa maneira de executar o aplicativo rapidamente no depurador (os comandos equivalentes, como os comandos de menu, são mostrados entre parênteses).

  1. Enquanto a execução de código é pausada na instrução name += letters[i], passe o mouse sobre a variável letters e você verá seu valor padrão, o valor do primeiro elemento na matriz char[10].

    Os recursos que permitem que você inspecione variáveis são uns dos mais úteis do depurador e há diferentes maneiras de fazer isso. Muitas vezes, ao tentar depurar um problema, você está tentando descobrir se as variáveis estão armazenando os valores que você espera que eles tenham em um determinado momento.

  2. Expanda a variável letters para ver suas propriedades, que incluem todos os elementos que a variável contém.

    Screenshot of the debugger paused at the 'name+= letters[I]' statement.

  3. Agora, passe o mouse sobre a variável name e você verá o valor atual dela: uma cadeia de caracteres vazia.

  4. Pressione F10 (ou escolha Depurar > Contornar) duas vezes para avançar para a chamada de método SendMessage e pressione F10 mais uma vez.

    Pressionar F10 avança o depurador até a próxima instrução sem intervir em funções ou métodos no código do aplicativo (o código ainda é executado). Ao pressionar F10 na chamada de método SendMessage, nós ignoramos o código de implementação de SendMessage (que, no momento, talvez não seja de nosso interesse).

  5. Pressione F10 (ou Depurar>Contornar) algumas vezes para iterar várias vezes no loop for, pausando novamente no ponto de interrupção e passando o mouse sobre a variável name a cada vez para verificar o valor dela.

    An animated screenshot of the Visual Studio Debugger showing the effect of pressing F10 to

    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 nesse cenário, você pode pressionar F5 (ou escolher Depurar>Continuar), avançando até o ponto de interrupção em vez da próxima instrução.

    Muitas vezes, ao depurar, você deseja uma maneira rápida de verificar valores de propriedade em variáveis, para ver se eles estão armazenando os valores que você espera que eles armazenem e as dicas de dados são uma boa maneira de fazer isso.

  6. Enquanto a execução de código permanece pausada no loop for no método Main, pressione F11 (ou escolha Depurar > Depuração total) até pausar na chamada de método SendMessage.

    Você deve estar nessa linha de código:

    SendMessage(name, a[i]);

  7. Pressione F11 mais uma vez para intervir no método SendMessage.

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

    Screenshot of the execution pointer at the SendMessage method.

    F11 é o comando Intervir, que avança a execução do aplicativo uma instrução por vez. F11 é uma boa maneira de examinar o fluxo de execução com o máximo de detalhes. Por padrão, o depurador ignora código que não é de usuário (se você quiser mais detalhes, consulte Apenas Meu Código).

    Digamos que você terminou de examinar o método SendMessage e deseja sair do método, mas permanecer no depurador. Você pode fazer isso usando o comando Depuração Circular.

  8. Pressione Shift + F11 (ou Depurar > Sair).

    Este comando retoma a execução do aplicativo (e avança o depurador) até que o método ou a função atual retorne.

    Você deve estar 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.

  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, 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.

    Screenshot of a debugger data tip in Visual Studio 2022 that shows the element values for the 'letters' array variable.

  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.

    Screenshot of a debugger data tip in Visual Studio 2022 that shows the string value for the 'name' variable.

    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 a execução de código estiver pausada no loop for do método Main, selecione F11 ou escolha o botão Depuração total na barra de ferramentas Depurar ou escolha Depurar>Depuração total na barra de menus até chegar à chamada do 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.

    Screenshot showing the execution pointer of the debugger within the 'SendMessage' method.

    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 entrada 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, consulte 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 do método SendMessage. Para obter mais informações sobre diferentes maneiras de percorrer seu código, confira Navegar pelo código no depurador.

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

  2. No editor de código, role para baixo e passe o mouse sobre o método Console.WriteLine no método SendMessage até que o botão verde Executar até o CliqueImage of the Run to Click button. apareça. A dica de ferramenta do botão mostra "Executar execução até aqui".

    Screenshot of the Run to Click button.

    Observação

    O botão Executar até o Clique é novo no Visual Studio 2017. (Se o botão de seta verde não for exibido, use F11 neste exemplo para avançar o depurador até o lugar certo.)

  3. Selecione o botão Executar para clicar. Image of the Run to Click button.

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

    O uso desse botão é semelhante à configuração de um ponto de interrupção temporário. Executar até o Clique é útil para se locomover rapidamente em uma região visível do código do aplicativo (você pode selecionar em qualquer arquivo aberto).

  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. A dica de ferramenta do botão mostra "Executar execução até aqui".

    Screenshot showing the Run to Click button in Visual Studio 2022.

  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

Selecione o botão ReiniciarImage of the Restart App button. na Barra de Ferramentas de Depuração (Ctrl + Shift + F5).

Ao pressionar Reiniciar, você economiza tempo em comparação com a opção de parar o aplicativo e reiniciar o depurador. O depurador é pausado no primeiro ponto de interrupção que é atingido pela execução do código.

O depurador vai parar novamente no ponto de interrupção que você definiu anteriormente dentro do loop for.

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.

Screenshot of the Restart button in the Debug toolbar of Visual Studio 2022.

O comando Reiniciar interrompe o depurador e, em seguida, reinicia-o em apenas uma etapa. Quando o depurador é reiniciado, ele é executado no primeiro ponto de interrupção, que é o ponto de interrupção definido anteriormente dentro do loop for e, em seguida, pausa.

Inspecionar variáveis com as janelas Autos e Locais

  1. Examine a janela Autos na parte inferior do editor de códigos.

    Se estiver fechado, abra-o enquanto estiver em pausa no depurador escolhendo Depurar>Janelas>Autos.

    Na janela Autos, veja as variáveis e seus valores atuais. A janela Autos mostra todas as variáveis usadas na linha atual ou a linha anterior (verifique a documentação para saber o comportamento específico a uma linguagem).

  2. Em seguida, examine a janela Locais, em uma guia ao lado da janela Autos.

  3. Expanda a variável letters para mostrar os elementos que ela contém.

    Screenshot of the Locals Window in Visual Studio.

    A janela Locais mostra as variáveis que estão no escopo atual, ou seja, o contexto de execução atual.

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.

    Screenshot of the Locals window in Visual Studio 2022, with the 'letters' array variable expanded.

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

Na janela principal do editor de código, clique com o botão direito do mouse na variável name e escolha Adicionar Inspeção.

A janela Inspeção é aberta na parte inferior do editor de códigos. Você pode usar uma janela Inspeção para especificar uma variável (ou uma expressão) que deseja acompanhar.

Agora há uma inspeção definida na variável name e você pode ver o valor sendo alterado enquanto percorre o depurador. Ao contrário das outras janelas variáveis, a janela Inspeção sempre mostra as variáveis que você está assistindo (elas ficam esmaecidas quando fora do escopo).

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 variáveis, a janela Inspeção sempre mostra as variáveis que você está assistindo. Variáveis fora do escopo são exibidas como indisponíveis.

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

Examinar a pilha de chamadas

  1. Enquanto a execução do código é pausada no loop for, selecione a janela Pilha de Chamadas, que é aberta por padrão no painel inferior direito.

    Se estiver fechado, abra-o enquanto estiver em pausa no depurador escolhendo Depurar>Janelas>Pilha de Chamadas.

  2. Selecione F11 algumas vezes até que o depurador seja pausado no método SendMessage. Examine a janela Pilha de Chamadas.

    Screenshot of the Call Stack window in Visual Studio.

    A janela Pilha de Chamadas mostra a ordem em que os métodos e as funções são chamados. A linha superior mostra a função atual (o método SendMessage neste aplicativo). A segunda linha mostra que SendMessage foi chamado por meio do método Main e assim por diante.

    Observação

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

    A pilha de chamadas é uma boa maneira de examinar e entender o fluxo de execução de um aplicativo.

    Você pode clicar duas vezes em uma linha de código para examinar esse código-fonte, que também altera o escopo atual em 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 até o Cursor e examinar o código-fonte. Para obter mais informações, confira Como 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 Main atual.

  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.

    Screenshot of the Call Stack window in Visual Studio 2022.

    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 em 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 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

  1. Pressione F11 duas vezes para executar o método Console.WriteLine.

  2. Com o depurador pausado na chamada do método SendMessage, use o mouse para pegar a seta amarela ou o ponteiro de execução (na margem esquerda) e arraste o ponteiro para cima uma linha até a instrução Console.WriteLine.

  3. Pressione F11.

    O depurador executa novamente o método Console.WriteLine (você vê essa ação na saída da janela do console).

    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

    Geralmente, você precisa ter cuidado com esse recurso. Um aviso é exibido na dica de ferramenta. Outros avisos também podem ser exibidos. Ao mover o ponteiro não é possível reverter o aplicativo para um estado anterior.

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

    Parabéns por concluir este tutorial.

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ê vê 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