Guia de início rápido: Navegação do depurador (Xaml e C#)

Este início rápido demonstra como navegar em sessões de depuração do Visual Studio e como exibir e alterar o estado do programa em uma sessão.

Este início rápido destina-se aos desenvolvedores que não têm experiência em depuração com o Visual Studio e aos desenvolvedores que desejam saber mais sobre como navegar em uma sessão de depuração do Visual Studio. Ele não ensina a arte da depuração propriamente dita. Os métodos no código de exemplo foram criados somente para demonstrar os procedimentos de depuração descritos neste tópico. Os métodos não empregam práticas recomendadas de design de aplicativos ou funções. Na verdade, você logo descobrirá que os métodos, e o aplicativo em si, não fazem muita coisa.

As seções deste início rápido foram elaboradas para serem tão independentes quanto possível; assim, você pode ignorar qualquer seção que incluir informações que já sejam do seu conhecimento. Além disso, não é obrigatório criar um aplicativo de exemplo; no entanto, nós recomendamos que isso seja feito e procuramos facilitar o processo ao máximo.

Atalhos do teclado para depuradores. A navegação no depurador do Visual Studio é otimizada para o mouse e o teclado. Várias das etapas deste tópico incluem o acelerador do teclado ou a tecla de atalho em um comentário entre parênteses. Por exemplo, (teclado: F5) indica que pressionar a tecla F5 inicia ou continua a execução do depurador.

Neste tópico

Você pode aprender como:

• Create the sample app

• Set and run to a breakpoint, step into a method, and examine program data

• Step into, over, and out of methods

• Set a conditional breakpoint, run to the cursor, and visualize a variable

• Edit and continue, recover from an exception

Criar o aplicativo de exemplo

A depuração envolve o código e, portanto, o aplicativo de amostra usa a estrutura do aplicativo da Windows Store somente para criar um arquivo de origem em que você possa ver como a navegação em uma sessão de depuração funciona e como examinar e alterar o estado do programa. Todo o código que você invocará é chamado pelo construtor da página principal; nenhum controle é adicionado e nenhum evento é tratado.

Crie um aplicativo padrão da Windows Store em C#. Abra o Visual Studio. Na página inicial, escolha o link Novo Projeto. Na caixa de diálogo Novo Projeto, selecione Visual C# na lista Instalado e selecione Windows Store. Na lista de modelos de projeto, escolha Aplicativo. O Visual Studio cria uma nova solução e um novo projeto, e exibe o designer MainPage.xaml e o editor de códigos XAML.

Abra o arquivo de origem MainPage.xaml.cs. Clique com o botão direito do mouse em qualquer lugar no editor XAML e escolha Exibir Código. O arquivo code-behind MainPage.xaml.cs é exibido. Observe que apenas um método, o construtor MainPage(), é listado no arquivo.

Substitua o construtor MainPage pelo código de exemplo. Exclua o método MainPage(). Siga este link: Código de exemplo da navegação do depurador (Xaml e C#) e copie o código listado na seção C# para a área de transferência. (Escolha Voltar no navegador ou no visualizador da ajuda para retornar a esta página do início rápido.) No editor do Visual Studio, cole o código no bloco partial class MainPage. Escolha CTRL + S para salvar o arquivo.

Agora você pode prosseguir acompanhando com os exemplos deste tópico.

Definir e executar até um ponto de interrupção, fazer step-into de um método e examinar dados do programa

A maneira mais comum de iniciar uma sessão de depuração é escolher Iniciar Depuração no menu Depurar (teclado: F5). A execução começa e continua até que um ponto de interrupção seja alcançado, você suspenda a execução manualmente, ocorra uma exceção ou o aplicativo chegue ao fim.

Quando a execução é suspensa no depurador, é possível exibir o valor de uma variável ativa em uma dica de dados focalizando o mouse sobre a variável. Você também pode abrir as janelas Locais e Autos para ver listas das variáveis ativas e os respectivos valores atuais. A adição de uma ou mais variáveis a uma janela Inspeção permite que você se concentre no valor das variáveis enquanto a execução do aplicativo continua.

Depois de suspender a execução do aplicativo (ou seja, interromper o depurador), você controla a maneira como o restante do código do programa é executado. Você pode continuar linha por linha, passando de uma chamada de método para o próprio método, ou pode executar um método chamado em uma única etapa. Esses são os procedimentos seguidos na depuração do aplicativo. Você também pode retomar a execução padrão do aplicativo, até o próximo ponto de interrupção definido ou até a linha onde o cursor está posicionado. Você pode parar a sessão de depuração a qualquer momento. O depurador foi projetado para realizar as operações de limpeza necessárias e sair da execução.

Exemplo 1

Neste exemplo, você define um ponto de interrupção no construtor MainPage do arquivo MainPage.xaml.cs, faz step-into do primeiro método, exibe os valores das variáveis e interrompe a depuração.

Defina um ponto de interrupção. Defina um ponto de interrupção na instrução methodTrack = "Main Page"; no construtor MainPage. Escolha a linha na medianiz sombreada do editor de código-fonte (teclado: posicione o cursor na linha e escolha a tecla F9).

O ícone de ponto de interrupção aparece na medianiz.

Execute até o ponto de interrupção. Inicie a sessão de depuração escolhendo Iniciar Depuração no menu Depurar (teclado: F5).

O aplicativo começa a ser executado e a execução é suspensa imediatamente antes da instrução em que você definiu o ponto de interrupção. O ícone de linha atual na medianiz identifica onde você está, e a instrução atual está realçada.

Agora você está no controle da execução do aplicativo e pode examinar o estado do programa à medida que avança pelas instruções.

Faça step-into do método. No menu Depurar, escolha Depuração Completa (teclado: F11).

Observe que o depurador passa para a linha seguinte, que é uma chamada para o método Example1. Escolha Depuração Completa novamente. O depurador passa para o ponto de entrada do método Example1. Isso indica que o método foi carregado na pilha de chamadas e a memória para as variáveis locais foi alocada.

Quando você faz step-into de uma linha de código, o depurador executa uma das seguintes ações:

• Se a instrução seguinte não é uma chamada para uma função na solução, o depurador executa a instrução, passa para a instrução seguinte e suspende a execução.

• Se a instrução é uma chamada para uma função na solução, o depurador passa para o ponto de entrada da função chamada e suspende a execução.

Continue a fazer step-into das instruções de Example1 até atingir o ponto de saída. O depurador realça a chave de fechamento do método.

Examine os valores das variáveis nas dicas de dados. Quando você focaliza o mouse em um nome de variável, o nome, o valor e o tipo da variável são exibidos em uma dica de dados.

Focalize o mouse na variável a. Note o nome, o valor e o tipo de dados. Focalize o mouse na variável methodTrack. Mais uma vez, note o nome, o valor e o tipo de dados.

Examine os valores das variáveis na janela Locais. No menu Depurar, aponte para Janelas e escolha Locais (teclado: Alt+4).

As janelas Locais formam um modo de exibição de árvore com os parâmetros e as variáveis da função. As propriedades de uma variável de objeto são nós filho do próprio objeto. A variável this é um parâmetro oculto em cada método de objeto que representa o objeto propriamente dito. Neste caso, ela representa a classe MainPage. Como methodTrack é um membro da classe MainPage, seu valor e tipo de dados são listados em uma linha abaixo de this. Expanda o nó this para exibir as informações de methodTrack.

Adicione uma inspeção para a variável methodTrack. A variável methodWatch é usada em todo este início rápido para mostrar os métodos chamados nos exemplos. Para ficar mais fácil visualizar o valor da variável, adicione-a a uma janela Inspeção. Clique com o botão direito do mouse no nome da variável na janela Locais e escolha Adicionar Inspeção.

Você pode inspecionar diversas variáveis em uma janela Inspeção. Os valores das variáveis inspecionadas, assim como os valores na janela Locais e nas janelas de dica de dados, são atualizados sempre que a execução é suspensa. Você também pode adicionar variáveis à janela Inspeção usando o editor de códigos. Selecione a variável a ser inspecionada, clique com o botão direito do mouse e escolha Adicionar Inspeção.

Fazer step-into, step-over e step-out de métodos

Em contraste com fazer step-into de um método chamado por um método pai, fazer step-over de um método executa o método filho e depois suspende a execução no método de chamada enquanto o pai é retomado. Você pode fazer step-over de um método quando estiver familiarizado com a forma como o método funciona e tiver certeza de que sua execução não afetará o problema que você está investigando.

Fazer step-over de uma linha de código que não contém uma chamada de método executa a linha da mesma forma que fazer step-into da linha.

Fazer step-out de um método filho continua a execução do método e depois suspende a execução após o método retornar para o respectivo método de chamada. Você pode fazer step-out de uma função long quando tiver determinado que o restante da função não é significativo.

Tanto o step-over quanto o step-out de uma função executam a função.

Exemplo 2

Neste exemplo, você faz step-into, step-over e step-out de métodos.

Chame o método Example2 no construtor MainPage. Edite o construtor MainPage e substitua a linha depois de methodTrack = String.Empty; por Example2();.

Execute até o ponto de interrupção. Inicie a sessão de depuração escolhendo Iniciar Depuração no menu Depurar (teclado: F5). O depurador suspende a execução no ponto de interrupção.

Faça step-over da linha de código. No menu Depurar, escolha Depuração Parcial (teclado: F10). O depurador executa a instrução methodTrack = "MainPage"; do mesmo modo como fez no step-into da instrução.

Faça step-into de Example2 e Example2_A. Escolha a tecla F11 para fazer step-into do método Example2. Continue a fazer step-into das instruções de Example2 até atingir a linha int x = Example2_A();. Novamente, faça step-into dessa linha para seguir para o ponto de entrada de Example2_A. Continue a fazer step-into de cada instrução de Example2_A até retornar a Example2.

Faça step-over de uma função. Observe que a próxima linha de Example2 – int y = Example2_A(); – é basicamente a mesma que a linha anterior. Você pode fazer step-over dessa linha com segurança. Escolha a tecla F10 para passar do reinício de Example2 para esta segunda chamada a Example2_A. Escolha F10 para fazer step-over desse método. Observe que a cadeia de caracteres methodTrack indica que o método Example2_A foi executado duas vezes. Você também pode notar que o depurador passa imediatamente para a próxima linha. Ele não suspende a execução no ponto em que Example2 é retomado.

Faça step-out de uma função. Escolha a tecla F11 para fazer step-into do método Example2_B. Observe que Example2_B não é muito diferente de Example2_A. Para fazer step-out do método, escolha Depuração Circular no menu Depurar (teclado: Shift + F11). Observe que a variável methodTrack indica que Example2_B foi executado e que o depurador retornou ao ponto onde Example2 é retomado.

Pare a depuração. No menu Depurar, escolha Parar Depuração (teclado: Shift+F5). Isso encerra a sessão de depuração.

Definir um ponto de interrupção condicional, executar até o cursor e visualizar uma variável

Um ponto de interrupção condicional especifica uma condição que faz com que o depurador suspenda a execução. A condição é especificada por qualquer expressão de código que possa ser avaliada como true ou false. Por exemplo, você pode usar um ponto de interrupção condicional para examinar o estado do programa em um método chamado com frequência somente quando uma variável atingir determinado valor.

Executar até o cursor é como definir um único ponto de interrupção. Quando a execução é suspensa, você pode selecionar uma linha na fonte e retomar a execução até que a linha selecionada seja alcançada. Por exemplo, você pode percorrer um loop em um método e determinar que o código no loop está sendo executado corretamente. Em vez de percorrer cada iteração do loop, você pode executar até o cursor que está posicionado depois que o loop é executado.

Às vezes, é difícil ver um valor de variável na linha da dica de dados ou na janela da variável. O depurador pode exibir cadeias de caracteres, HTML e XML em um visualizador de texto que apresenta uma exibição formatada do valor em uma janela rolável.

Exemplo 3

Neste exemplo, você define um ponto de interrupção condicional para interromper uma iteração específica de um loop, depois executa até o cursor que está posicionado após o loop. Você também exibe o valor de uma variável em um visualizador de texto.

Chame o método Example3 no construtor MainPage. Edite o construtor MainPage e substitua a linha depois de methodTrack = String.Empty; pela linha Example3();.

Execute até o ponto de interrupção. Inicie a sessão de depuração escolhendo Iniciar Depuração no menu Depurar (teclado: F5). O depurador suspende a execução no ponto de interrupção no método MainPage.

Faça step-into do método Example3. Escolha Depuração Total no menu Depurar (teclado: F11) para ir até o ponto de entrada do método Example3. Continue fazendo step-into do método até ter iterado um ou dois loops do bloco for. Observe que demoraria muito para percorrer todas as 1.000 iterações.

Defina um ponto de interrupção condicional. Na medianiz esquerda da janela de código, clique com o botão direito do mouse na linha x += i; e escolha Condição. Marque a caixa de seleção Condição e digite i == 500; na caixa de texto. Escolha a opção É verdadeiro e clique em OK. O ponto de interrupção permite que você verifique o valor na iteração de número 500 do loop for.

Um ícone de ponto de interrupção condicional pode ser identificado pela cruz branca.

Execute até o ponto de interrupção. No menu Depurar, escolha Continuar (teclado: F5). Na Janela de locais, confirme se o valor atual de i é 500. Observe que a variável s é representada como uma única linha e é muito mais maior que a janela.

Visualize uma variável string. Clique no ícone de lupa na coluna Valor da variável s.

A janela Visualizador de Texto é exibida e o valor da cadeia de caracteres é apresentado como uma cadeia de caracteres de várias linhas.

Execute até o cursor. Clique com o botão direito do mouse na linha methodTrack += "->Example3"; e escolha Executar até o Cursor (teclado: mova o cursor para a linha; Ctrl + F10). O depurador conclui as iterações do loop e suspende a execução na linha.

Pare a depuração. No menu Depurar, escolha Parar Depuração (teclado: Shift+F5). Isso encerra a sessão de depuração.

Editar e continuar, recuperar de uma exceção

Em algumas circunstâncias, ao interromper o código no depurador do Visual Studio, você tem a oportunidade de alterar o valor das variáveis e até mesmo a lógica das instruções. Essa funcionalidade é chamada editar e continuar.

O recurso de editar e continuar pode ser especialmente útil quando você interrompe em uma exceção. Em vez de precisar interromper e reiniciar a depuração em um procedimento longo e complexo para evitar a exceção, você pode "desenrolar" a exceção para mover a execução para o ponto imediatamente anterior à ocorrência da exceção, e depois alterar a variável ou instrução incorreta e continuar com a sessão de depuração atual em um estado que não gera uma exceção.

Embora você possa usar o recurso de editar e continuar em uma ampla variedade de situações, as condições específicas que não oferecem suporte a ele são difíceis de determinar, pois dependem da linguagem de programação, do estado atual da pilha do programa e da capacidade do depurador de alterar o estado sem corromper o processo. A melhor maneira de determinar se há suporte para uma alteração de edição é experimentá-la; o depurador avisa imediatamente se é o caso ou não.

Exemplo 4

Neste exemplo, você executa o depurador até uma exceção, desenrola a exceção, corrige a lógica do método e altera o valor de uma variável para poder continuar a executar o método.

Chame o método Example4 no construtor MainPage. Edite o construtor MainPage() e substitua a linha depois de methodTrack = String.Empty; pela linha Example4();.

Execute até a exceção. Inicie a sessão de depuração escolhendo Iniciar Depuração no menu Depurar (teclado: F5). Pressione F5 novamente para retomar a execução. O depurador suspende a execução na exceção no método Example4 e exibe uma caixa de diálogo de exceção.

Altere a lógica do programa. É óbvio que o erro está na condição if: o valor de x deve ser alterado quando x é igual a 0, não quando x é diferente de zero. Escolha Interromper para corrigir a lógica do método. Quando você tenta editar a linha, é exibida outra caixa de diálogo.

Escolha Editar e altere a linha if (x != 0) para if (x == 0). O depurador leva as alterações feitas na lógica do programa para o arquivo de origem.

Altere o valor da variável. Examine o valor de x em uma dica de dados ou na janela Locais. Ele ainda é 0 (zero). Se você tentar executar a instrução que causou a exceção original, esta será gerada novamente. Você pode alterar o valor de x. Na janela Locais, clique duas vezes na coluna Valor da linha x. Altere o valor de 0 para 1.

Escolha a tecla F11 para fazer step-into da instrução que anteriormente gerou uma exceção. Observe que a linha é executada sem erro. Escolha F11 novamente.

Pare a depuração. No menu Depurar, escolha Parar Depuração (teclado: Shift+F5). Isso encerra a sessão de depuração.

Consulte também

Conceitos

Como iniciar uma sessão de depuração (Visual C++, visual C# e Visual Basic)

Como disparar eventos de suspensão, retomada e no plano de fundo em aplicativos da Windows Store

Depurando aplicativos da Windows Store