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

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ê 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. O instalador do Visual Studio é iniciado. Escolha a carga de trabalho de desenvolvimento de desktop .NET e, em seguida, escolha Modificar.

3. Na janela Criar um novo projeto , digite console na caixa de pesquisa. 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.

4. Na janela Configurar seu novo projeto , digite get-started-debugging na caixa Nome do projeto . Em seguida, selecione Avançar.

5. Na janela Informações adicionais , verifique se .NET 8.0 está selecionado no menu suspenso Framework e selecione Criar.

1. 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, mas neste momento não fizemos nada de especial para examinar o código. Assim, o aplicativo apenas carrega e você vê 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
   

   Neste tutorial, você dá uma olhada mais de perto neste aplicativo usando o depurador e dá uma olhada nos recursos do depurador.

2. Pare o depurador pressionando (Shift + F5) ou selecione o botão vermelho Parar depuração na barra de ferramentas Depurar.

   

3. Na janela do console, pressione uma tecla para fechar a janela do console.

1. 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 deve suspender seu código em execução para que você possa examinar os valores das variáveis, ou o comportamento da memória, ou se uma ramificação do 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 de Depuração, o aplicativo é iniciado e o depurador é executado até a linha de código onde você define 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 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 obter 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.

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

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

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

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

   

   F11 é o comando Step Into e avança a execução do aplicativo uma instrução de cada vez. F11 é uma boa maneira de examinar o fluxo de execução com mais detalhes. (Para avançar mais rapidamente através do código, mostramos-lhe algumas outras opções também.) Por padrão, o depurador ignora o código de não-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 na ferramenta de depuração. Você pode fazer isso usando o comando Step out .

3. Pressione Shift + F11 (ou Debug > Step out).

   Este comando retoma a execução do aplicativo (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.

4. Pressione F11 várias vezes até voltar novamente para a chamada do método SendMessage.

5. Enquanto a execução de código é pausada na chamada do método, pressione F10 (ou escolha Debug > Step Over) uma vez.

   

   Observe que 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 sua aplicação (o código ainda é executado). Ao pressionar F10 na SendMessage chamada de método (em vez de F11), ignoramos o código de implementação para SendMessage (no qual talvez não estejamos interessados no momento). Para obter mais informações sobre diferentes maneiras de navegar pelo seu código, consulte Navegar no código no depurador.

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 dentro do método SendMessage até que o botão verde Executar até Clicar apareça. A dica de ferramenta para o botão mostra "Executar até aqui".

   

3. 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 navegar rapidamente por uma região visível do código do aplicativo (pode selecionar em qualquer ficheiro aberto).

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

Recursos que permitem inspecionar variáveis são um dos recursos mais úteis do depurador, e há diferentes maneiras de fazê-lo. 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.

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

2. Em seguida, passe o mouse sobre a name variável e você verá seu valor atual, uma cadeia de caracteres vazia.

3. 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, ao depurar, você quer uma maneira rápida de verificar os valores de propriedade em variáveis, para ver se elas estão armazenando os valores que você espera que elas armazenem, e as dicas de dados são uma boa maneira de fazer isso.

1. 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 (Verifique a documentação quanto ao comportamento específico do idioma).

2. Em seguida, olhe para a janela Locais, na aba ao lado da janela Automáticos.

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

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

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

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

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

2. 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 (o SendMessage método neste aplicativo). 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 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 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.