Tutorial: aprenda a depurar código do Visual Basic usando o Visual Studio

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 Visual Basic, a maioria dos recursos é aplicável a C#, C++, 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 no Visual Basic.

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ê 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 de área de trabalho do .NET e, em seguida, 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.

3. Na janela Criar um projeto, insira console na caixa de pesquisa. Em seguida, escolha Visual Basic 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.

   

   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.

4. Na janela Configurar seu novo projeto, insira iniciar-depuração na caixa 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

No Program.cs, substitua todos os códigos padrão pelo seguinte código:

Imports System

Class ArrayExample
  Public Shared Sub Main()
    Dim letters As Char() = {"f"c, "r"c, "e"c, "d"c, " "c, "s"c, "m"c, "i"c, "t"c, "h"c}
    Dim name As String = ""
    Dim a As Integer() = New Integer(9) {}

    For i As Integer = 0 To letters.Length - 1
      name += letters(i)
      a(i) = i + 1
      SendMessage(name, a(i))
    Next

    Console.ReadKey()
  End Sub

  Private Shared Sub SendMessage(ByVal name As String, ByVal msg As Integer)
    Console.WriteLine("Hello, " & name & "! Count to " & msg)
  End Sub
End Class

Inicie o depurador.

1. Pressione F5 (Depurar >Iniciar depuração) ou selecione o botão verdeIniciar depuração 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 é carregado e a saída do console é exibida.

   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. Interrompa o depurador pressionando (Shift + F5) ou selecione o botão vermelho Parar depuração na Barra de Ferramentas de Depuração.

   

3. Na janela do console, pressione uma 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 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 (Depurar >Iniciar Depuração) ou o botão Iniciar Depuração na barra de ferramentas Depurar, o aplicativo será iniciado e o depurador executará a linha de código em que você definiu o ponto de interrupção.

   

   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.

Navegar pelo código no depurador usando comandos de etapa

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

1. Enquanto a execução do código estiver em pausa no loop For no método Main, pressione duas vezes F11 (ou escolha Depurar > Intervir) para avançar para a chamada de método SendMessage.

   Depois de pressionar F11 duas vezes, você deve estar nessa linha de código:

   SendMessage(name, a(i))

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

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

   

   F11 é o comando Intervir e 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. (Também vamos mostrar algumas outras opções para percorrer o código com mais rapidez.) 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.

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

4. Pressione F11 várias vezes até voltar à chamada de método SendMessage novamente.

5. Enquanto a execução de código estiver em pausa na chamada de método, pressione F10 (ou escolha Depurar > Passo a passo) uma vez.

   

   Observe neste momento que o depurador não intervém no método SendMessage. F10 avança o depurador sem intervir em funções ou métodos no código do aplicativo (o código ainda é executado). Pressionando F10 na chamada do método SendMessage (em vez de F11), ignoramos o código de implementação de SendMessage (que, no momento, talvez não seja de nosso interesse). 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. Pressione 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 Clique apareça. A dica de ferramenta do botão mostra "Executar execução até aqui".

   

3. Selecione o botão Executar para clicar.

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

Reinicie o aplicativo rapidamente

Para reiniciar o aplicativo, pressione a combinação de teclas Ctrl + Shift + F5, ela economiza tempo em vez 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.

Inspecionar variáveis com dicas de dados

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.

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 "f"c.

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

3. Pressione F5 (ou Depurar>Continuar) 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 seu valor.

   

   O valor da variável é alterado a cada iteração do loop For, mostrando valores de f, depois fr, fre e assim por diante.

   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.

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 a execução de código 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.

   

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

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 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 a execução de código 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.

   

   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. Isso também altera 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 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.

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. Você também pode ver outros avisos. 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.

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