Breakpoints: com depurar suas aplicações - Revista easy .Net Magazine 19

Desenvolver um bom software sem realizar sua devida depuração é algo praticamente impossível, considerando a realidade dos projetos de software que existem hoje em dia. Sempre haverá algum ponto do código que irá estar sujeito a algum tipo de falha, seja nos momentos em que novos requisitos forem incluídos, novas plataformas forem suportadas ou mesmo ao interagir com outras partes de software.

Os bons projetos precisam reduzir o índice de bugs para o menor número possível, mas, precisam também facilitar a localização e solução destes quando surgirem. Estas são desde as mais básicas, como a interrupção do código para inspeção dos objetos na memória – o que é feito pelo já conhecido breakpoint, até preparar o código das classes para que apresentem informações que ajudem o programador a identificar o que está “acontecendo” com o seu código em um determinado ponto da execução.

É fato que quanto maior e mais complexo o projeto, mais difícil será fazer a depuração, entretanto, com as técnicas apresentadas aqui, até mesmo projetos imensos podem ser depurados e ter seus problemas resolvidos.

Resolvendo problemas na aplicação

Tudo se inicia dentro da IDE do Visual Studio ao se executar o código do projeto que é o objeto de depuração.

Neste artigo vamos considerar apenas a depuração de códigos baseados em aplicações que tenham alguma interface com o usuário, como aplicativos Windows Forms, WPF, ASP.NET etc. Os tópicos apresentados aqui são mais indicados para estes tipos de projetos, mas, também é possível realizar a depuração em outros, como Webservices e serviços do Windows, para serem depurados quando o código está disponível ou até mesmo, fazer a depuração de processos remotamente localizados.

Para iniciar a depuração é preciso que o código esteja sendo executado - aqui cabe uma observação importante para os programadores iniciantes: uma class library precisa estar anexada com um projeto executável que seja uma UI (interface com o usuário) para poder ser depurado. Se você tentar depurar um projeto deste tipo no Visual Studio, vai receber uma mensagem de que não é possível executar diretamente um projeto deste tipo.

Os primeiros passos para entender como funciona a depuração é conhecer as duas modalidades para compilação e execução de um projeto, que são Debug e Release. Projetos no modo Debug incluem informações que facilitam a localização no código, como a call stack – que é a hierarquia de chamadas dos métodos e classes – contendo o número da linha da chamada no código e outros dados importantes para depuração, estes, que serão mostrados nos próximos tópicos.

Normalmente, a opção escolhida para a compilação do projeto é o modo Debug (este é utilizado durante o desenvolvimento/testes da aplicação) e após, é alterado para o modo Release para ser enviado ao usuário final.

A maneira mais simples de alterar o modo de compilação do projeto é através da barra de ferramentas, como ilustrado na Figura 1. Este modo é selecionado como padrão ao criar um novo projeto.

Existem algumas formas de iniciar a depuração de seu aplicativo: clicando no botão executar (ao lado do seletor de modo, na barra de ferramentas), pressionando F5, utilizando o meu Debug > Start Debugging ou na janela Solution Explorer, com o botão direito sobre o ícone do projeto, escolhendo Debug > Start Debugging (Figura 2).

Com este processo, eventuais breakpoints informados no projeto serão executados, mas, é importante entender primeiramente algumas características dos breakpoints.

Breakpoint

Estes são pontos de parada na execução do código para que seja possível inspecionar principalmente a memória e visualizar os objetos que estão carregados.

Para estabelecer um breakpoint basta ir ao ponto do código que se deseja inspecionar pressionar F9 ou ainda, realizar um click (criando um círculo vermelho) na faixa do lado esquerdo da linha que deseja parar. A Figura 3 mostra um breakpoint definido.

 Quando o programa (sendo executado em modo de depuração) atingir o ponto definido, o programa suspende a execução e a janela do Visual Studio é exibida neste ponto, como na Figura 4.

Quando um breakpoint é atingido, várias ações podem ser tomadas pelo programador. Primeiramente, se pararmos com o ponteiro do mouse sobre os objetos que fazem parte do contexto da execução, o IntelliSense do Visual Studio mostra parte do conteúdo destes, conforme pode ser conferido na Figura 5.

 Neste exemplo, junto ao tipo do objeto (DebugDemo.Classes.Empregado), no lado esquerdo, é possível expandir o conteúdo clicando no sinal “+”, que exibe detalhes do objeto.

Esta janela é recursiva e permite expandir os objetos que estão dentro do objeto inicial em cascata.

Também é possível inspecionar os objetos através da janela Locals, que fica na região inferior da janela do Visual Studio. A Figura 6 mostra o objeto sendo inspecionado por esta janela.

Além da variável objeto do contexto onde o breakpoint foi colocado, também as demais que fazem parte do contexto do método são exibidas, como this – que referencia a classe do método em questão, os objetos sender e “e” que são os argumentos passados para o método.

Outra janela útil no processo de depuração é a Immediate Window (Figura 7). Nela é possível interagir com os objetos acessando suas propriedades e fazendo chamada a métodos da classe e códigos do C#.

 O programa permanecerá pausado até pressionar F5 para continuar a execução ou interromper sua execução definitivamente pela barra de ferramentas ou através do atalho SHIFT+F5 do teclado. Mas, outras ações podem ser tomadas, por exemplo, Step Over e Step Into.

 Step Over e Step Into

Além de prosseguir ou interromper definitivamente a execução do programa, é possível ir executando passo a passo o código com Step Over e Step Into.

O Step Over faz com que o código passe para a próxima instrução dentro do método atual, executando o programa linha a linha dentro deste. Para fazer isto, você pode utilizar a tecla F10 do teclado ou ainda o menu Debug > Step Over.

Já com Step Into, o código navega para dentro dos códigos dos métodos chamados, o que é útil quando se deseja inspecionar um programa, mais precisamente, quando há dúvidas sobre em qual método o problema pode ser encontrado.

A Figura 8 mostra um Step Into sendo executado no breakpoint que foi definido anteriormente.

 Observe que a execução foi desviada para outra classe, no método CalcularSalarioFamilia, conforme o sombreado amarelo da figura indica. O limite para esta funcionalidade é a disponibilidade de código. Se houver o código-fonte disponível dentro do projeto, o mesmo será exibido. Assim, não é possível inspecionar ou debugar métodos ou classes de class libraries que foram adicionadas ao projeto e que não há o código presente.

A tecla de atalho para Step Into é F11 ou menu Debug > Step Into.

Novamente, estão disponíveis nas janelas Immediate Window, Locals e o InteliSense para inspecionar o conteúdo dos objetos.

Condições para breakpoint

Um recurso interessante do breakpoint é aquele que permite estabelecer uma condição lógica para que haja uma parada no código.

Considere, por exemplo, uma coleção extensa de dados. Durante os testes, observou-se que somente há problema no código quando atinge um item em especial nesta lista.

Com o breakpoint condicional, você pode fazer com que o programa só seja suspenso quando uma determinada condição – que pode ser expressa utilizados códigos C# que você está acostumado – for verdadeira. Para isso, deve clicar com o botão direito do mouse sobre o breakpoint (em tempo de execução ou de projeto) e acessar o menu Conditions, que faz com que a janela da Figura 9 seja exibida para escrever a condição desejada.

Como é possível perceber, o InteliSense está disponível também nesta janela, o que facilita a construção de expressões para o breakpoint.

Quando o código for executado, somente será feita a parada ao atingir a expressão que está definida. Mas, nem só de breakpoint é feita a depuração no Visual Studio.

Escrevendo na janela Output

A IDE do Visual Studio possui uma janela chamada Output que normalmente mostra informações geradas durante a compilação do projeto.

Entretanto, esta também pode ser utilizada para auxiliar a depuração do código da aplicação. Para fazer isto, basta incluir em seu código – tanto faz se numa classe de uma class library ou interface de usuário, a instrução “Console.Writeline”. Observe a "

A exibição deste artigo foi interrompida.

  Este é um post disponível para assinantes MVP

Este post também está disponível para assinantes da Easy .net magazine
ou para quem possui Créditos DevMedia.  Clique aqui para saber mais!

Saiba como acessar este post através de Créditos DevMedia:

Assinatura de Créditos – Aqui este post custa R$ 1,50
Com esse plano você compra R$ 180,00 em créditos e ganha, em média, 80% de desconto no preço do post.  
Assine agora

Plano ocasional - Aqui este post custa: R$ 2,00 (assinante) ou R$ 2,50 (não-assinante)
Você compra um mínimo de R$ 60,00 em créditos e ganha, em média, 50% de desconto no preço do post.  
Compre agora

Plano conveniência – Neste plano este post custa R$ 5,00
Neste plano você compra somente um post, pagando seu preço sem desconto.  
Compre agora