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

Este artigo apresenta os recursos do depurador do Visual Studio em um passo a passo. Se quiser uma visão mais abrangente das funcionalidades do depurador, consulte a Visão Geral do depurador Visual Studio. 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 muitas maneiras de ver o que seu código está fazendo enquanto é executado.

Percorra o seu código e veja os valores armazenados nas variáveis.
Defina relógios nas variáveis para ver quando os valores mudam.
Examine o caminho de execução do seu código para ver se uma ramificação de código está a funcionar.

Se este exercício for a primeira vez que tentaste depurar código, talvez queiras ler Debugging para iniciantes absolutos.

Embora a aplicação de demonstração neste artigo utilize Visual Basic, a maioria das funcionalidades aplica-se a C#, C++, F#, Python, JavaScript e outras linguagens suportadas pelo Visual Studio. O F# não suporta Editar e continuar. F# e JavaScript não suportam a janela Autos . As capturas de tela estão no Visual Basic.

Neste tutorial, você:

Inicia o depurador e atinge os pontos de quebra
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

Deve ter o Visual Studio instalado, incluindo a carga de trabalho de desenvolvimento multiplataforma .NET Core .

Se precisares de instalar o Visual Studio, para uma versão gratuita, consulta downloads do Visual Studio.
Se você precisar instalar a carga de trabalho, mas já tiver o Visual Studio, vá para Ferramentas>Obter Ferramentas e Recursos..., que abre o Visual Studio Installer. Escolha a carga de trabalho de desenvolvimento de desktop .NET e, em seguida, escolha Modificar.

Criar um projeto

Primeiro, crie um projeto de aplicação de consola .NET Core. O tipo de projeto vem com todos os arquivos de modelo que você precisa, antes mesmo de adicionar qualquer coisa!

Abra o Visual Studio. Se a janela Iniciar não estiver aberta, selecione Ficheiro>Janela Iniciar.
Na janela Iniciar, selecione Criar um novo projeto.
Na janela Criar um novo projeto , na caixa de pesquisa, entre consola. Em seguida, escolha Visual Basic 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 para .NET Core e 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 encontrando o que você está procurando? , escolha o link Instalar mais ferramentas e recursos . Em seguida, no instalador do Visual Studio, escolha o workload de desenvolvimento de desktop .NET.
Na janela Configurar o seu novo projeto , para o nome do projeto, introduza get-started-debugging. Em seguida, selecione Avançar.
Na janela de informação adicional , certifique-se de que o .NET 10.0 está selecionado para Framework e depois selecione Criar.

Abra o Visual Studio. Se a janela Iniciar não estiver aberta, selecione Ficheiro>Janela Iniciar.
Na janela Iniciar, selecione Criar um novo projeto.
Na janela Criar um novo projeto , na caixa de pesquisa, entre consola. Em seguida, escolha Visual Basic 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 para .NET Core e 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 encontrando o que você está procurando? , escolha o link Instalar mais ferramentas e recursos . Em seguida, no instalador do Visual Studio, escolha o workload de desenvolvimento de desktop .NET.
Na janela Configurar o seu novo projeto , para o nome do projeto, introduza get-started-debugging. Em seguida, selecione Avançar.
Na janela de informação adicional , certifique-se de que o .NET 8.0 está selecionado para Framework e depois selecione Criar.

O Visual Studio abre seu novo projeto.

Criar o aplicativo

Em Program.vb, substitua todo o código padrão pelo seguinte:

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!

Pressione F5 (Depurar > Iniciar Depuração) ou selecione o botão verde Iniciar Depuração na Barra de Ferramentas Depurar.

F5 inicia a aplicação com o depurador anexado ao processo da aplicação. Até agora, não fizeste nada de especial para examinar o código. A aplicação simplesmente carrega e vês a saída da consola.
```
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ê dá uma olhada mais de perto neste aplicativo usando o depurador e dá uma olhada nos recursos do depurador.
Pare o depurador pressionando (Shift + F5) ou selecione o botão vermelho Parar depuração na barra de ferramentas Depurar.
Na janela do console, pressione uma tecla para fechar a janela do console.

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

For No loop da função, defina um ponto de Main 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 um dos recursos fundamentais e essenciais para uma depuração confiável. Um ponto de interrupção indica onde o Visual Studio suspende o seu código em execução. Durante a suspensão, pode ver os valores das variáveis ou o comportamento da memória. Podes ver se um ramo de código corre.
Pressiona F5 (Depurar > Iniciar Depuração) ou o botão Iniciar Depuração na Barra de Ferramentas de Depuração. A aplicação inicia, e o depurador corre até à linha de código onde defines o ponto de interrupção.

A seta amarela representa a instrução em que o depurador pausou, e também suspende a execução do aplicativo no mesmo ponto. Esta instrução ainda não foi executada.

Se o aplicativo ainda não estiver em execução, F5 inicia o depurador e para 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ê conhece a linha de código ou a seção de código que deseja examinar em detalhes. Para informações sobre os diferentes tipos de pontos de interrupção, veja Utilização de pontos de interrupção.

Navegar pelo código no depurador usando comandos step

Este artigo usa os atalhos de teclado, porque é uma boa forma de executar rapidamente a tua aplicação no depurador. Mostra comandos equivalentes, como comandos de menu, entre parênteses.

Enquanto a execução de código é pausada For no loop no Main método, pressione F11 (ou escolha Debug > Step Into) duas vezes para avançar para a chamada do SendMessage método.

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

SendMessage(name, a(i))
Pressione F11 mais uma vez para entrar no SendMessage método.

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

F11 é o comando Entrar. Avança a execução da aplicação uma declaração de cada vez. F11 é uma boa maneira de examinar o fluxo de execução com mais detalhes. Por padrão, o depurador ignora o código que não é do usuário. Para obter mais informações, consulte Just My Code.

Suponha que terminou de examinar o método SendMessage, e quer sair do método mas ficar no depurador. Você pode fazer isso usando o comando Step out .
Pressione Shift + F11 (ou Debug > Step out).

Este comando retoma a execução da aplicação e avança o depurador até que o método ou função atual retorne.

Você deve estar de volta no For loop no Main método, pausado na chamada do SendMessage método.
Pressione F11 várias vezes até voltar novamente para a chamada do método SendMessage.
Enquanto a execução de código é pausada na chamada do método, pressione F10 (ou escolha Debug > Step Over) uma vez.

Desta vez, o depurador não entra no método SendMessage. F10 avança o depurador sem entrar em funções ou métodos no código da tua aplicação. O código continua a executar-se. Ao pressionar F10 na SendMessage chamada ao método em vez de F11, saltou o código de implementação para SendMessage. Para obter mais informações sobre diferentes maneiras de navegar pelo seu código, consulte Navegar no código no depurador.

Navegue pelo código usando Executar para clicar

Pressione F5 para avançar para o ponto de interrupção novamente.
No editor de código, role para baixo e passe o mouse sobre o método Console.WriteLine dentro do método SendMessage até que o botão verde Executar até Clicar apareça. A dica de ferramenta do botão exibe Correr execução até neste ponto.
Selecione o botão Correr até Clicar.

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

Usar esse botão é semelhante a definir um ponto de interrupção temporário. Run to Click é útil para se deslocar rapidamente por uma região visível do código da aplicação, que se pode selecionar em qualquer ficheiro aberto.

Reinicie seu aplicativo rapidamente

Para reiniciar a sua aplicação, pressione a combinação de teclas Ctrl + Shift + F5 . Poupa tempo em vez de parar a aplicação e reiniciar o depurador. O depurador pausa no primeiro ponto de interrupção alcançado durante a execução do código.

O depurador para novamente no ponto de interrupção que você definiu anteriormente dentro do For loop.

Inspecione variáveis com dicas de dados

O depurador tem funcionalidades que permitem inspecionar variáveis. Existem diferentes formas de inspecionar variáveis. Muitas vezes, quando você tenta depurar um problema, está tentando descobrir se as variáveis estão armazenando os valores que você espera que elas tenham em um determinado momento.

Enquanto a execução do código está pausada na name += letters[i] instrução, passe o rato sobre a letters variável. Vê o seu valor padrão, o valor do primeiro elemento no array, "f"c.
De seguida, passe o rato sobre a name variável para ver o seu valor atual, uma cadeia vazia.
Pressione F5 (ou Debug>Continue) algumas vezes para iterar várias vezes através do For loop, pausando novamente no ponto de interrupção e passando o mouse sobre a name variável cada vez para verificar seu valor.

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.

Muitas vezes, quando depuras código, queres uma forma rápida de verificar os valores das propriedades das variáveis para ver se estão a armazenar os valores que esperas que armazenem. Sugestões de dados são uma boa forma de o fazer.

Inspecione variáveis com as janelas Autos e Locais

Observe a janela Autos na parte inferior do editor de código.

Se estiver fechado, abra-o enquanto a execução do código estiver pausada no depurador, escolhendo Depurar>Windows>Autos.

Na janela Automáticos , você vê variáveis e seu valor atual. A janela Autos mostra todas as variáveis usadas na linha atual ou na linha anterior. Consulte a documentação para comportamentos específicos da língua.
Em seguida, olhe para a janela Locais, na aba ao lado da janela Automáticos.
Expanda a letters variável para mostrar os elementos que ela contém.

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

Definir um relógio

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

Enquanto o depurador estiver pausado, clique com o botão direito do rato sobre a name variável e escolha Adicionar monitorização.

A janela Watch é aberta por padrão na parte inferior do editor de códigos.
Agora que definiu uma observação sobre a variável name, percorra o código para ver o valor da variável name mudar em cada iteração do for loop.

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

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

Examine a pilha de chamadas

Enquanto a execução de 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 é pausada no depurador, escolhendo Depurar>pilha de chamadas do>.
Selecione F11 algumas vezes até o depurador pausar no método SendMessage. Olhe para a janela Pilha de chamadas.

A janela Call Stack mostra a ordem em que os métodos e funções estão sendo chamados. A linha superior mostra a função atual. Neste exemplo, é o SendMessage método. A segunda linha mostra que SendMessage foi chamado a partir do Main método, e assim por diante.

Observação

A janela Call Stack é semelhante à perspetiva Debug em algumas ferramentas de programação 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 e isso também altera o escopo atual sob inspeção pelo depurador. Esta ação não avança o depurador.

Você também pode usar os menus de contexto com o botão direito do rato na janela da pilha de chamadas para realizar outras ações. Por exemplo, você pode inserir pontos de interrupção em funções especificadas, avançar o depurador usando Run to Cursor e examinar o código-fonte. Para obter mais informações, consulte Como examinar a pilha de chamadas.

Alterar o fluxo de execução

Pressione F11 duas vezes para executar o Console.WriteLine método.
Com o depurador pausado na chamada ao método SendMessage, arraste a seta amarela ou o ponteiro de execução na margem esquerda uma linha para cima até à instrução Console.WriteLine.
Pressione F11.

O depurador repete o método Console.WriteLine. Vês esta ação na saída da janela de consola.

Ao alterar o fluxo de execução, pode testar diferentes caminhos de execução de código ou reexecutar código sem reiniciar o depurador.

Advertência

Muitas vezes é preciso ter cuidado com esta funcionalidade. Há um aviso na dica de ferramenta. Você também pode ver outros avisos. Mover o ponteiro não pode reverter a sua aplicação para um estado anterior da aplicação.
Pressione F5 para continuar executando o aplicativo.

Parabéns por concluir este tutorial!

Neste tutorial, aprendeste a iniciar o depurador, passar pelo código e inspecionar variáveis. Você pode querer obter uma visão de alto nível dos recursos do depurador, juntamente com links para mais informações.

Visão geral do depurador do Visual Studio

Comentários

Esta página foi útil?

Last updated on 2026-02-25