Depuração e Tratamento de Erros no Visual Basic

Este capítulo se concentra nos enganos ou erros cometidos durante a codificação e o que fazer com eles. Independentemente da experiência que você tenha como programador, raramente os seus programas serão processados sem erros logo na primeira tentativa. E não importa o quão comportados sejam os usuários que trabalharão com os seus programas, eles tendem a encontrar ou provocar uma certa quantidade de erros durante a execução dos programas. Visualizaremos em primeiro lugar o processo de localização e remoção de bugs (erros) e então veremos os meios para tratar os erros de execução, à medida que ocorrem.

Bugs são aqueles insetos que infestam programas que você tem certeza de que estão perfeitos, apesar de não estarem produzindo os resultados corretos. Curiosamente, um dos primeiros bugs registrados em computadores era realmente um inseto. O computador Mark 11 era um computador eletromecânico construído em 1945. Um dia o computador misteriosamente parou de trabalhar. Uma busca cansativa finalmente revelou que havia uma traça presa entre os pontos de contato de um relê. Grace Murray Hopper, um dos criadores da linguagem COBOL e um pioneiro na indústria de computadores, retirou o infeliz lepidóptero, colocando-o no livro de registros com a anotação "Primeiro bug real encontrado".

Entretanto, os bugs discutidos neste capitulo são erros de lógica contidos nos seus programas. Naturalmente, você pode cometer vários tipos de erros que impedem seu programa de ser executado - por exemplo, tentar assinalar um valor string para uma variável do tipo double. O Visual Basic sinaliza esses erros simples assim que os encontra, facilitando a sua localização e correção. Os bugs realmente interessantes são os que você precisa encontrar e corrigir por si próprio.

Chama-se depuração o processo de localização e correção de bugs. Ao contrário dos processos tradicionais de exterminação de pestes, a depuração de programas de computador não tem efeitos colaterais, a menos que você leve em consideração as horas sem dormir e as incontáveis xícaras de café que podem ser necessárias para resolver um bug "cabeludo".

Depurar um programa pode ser interessante e até mesmo excitante. Trilhar e eliminar um bug de software normalmente traz um sentimento real de satisfação, seja em função da sensação de concertar o seu programa, de uma sensação de realização ou, ainda, devido apenas à própria emoção de caçar. O exercício mental pode ser elucidativo, permitindo-lhe examinar e analisar seu próprio mecanismo de pensamento.

Ferramentas de Depuração

Por mais que queiramos negar, todos os bugs realmente são erros de programação. Entretanto, alguns erros se manifestam de forma tão rara ou sobre condições tão anormais que parecem movidos por uma inteligência maligna, que sente prazer em nos confundir. O erro mais comum é uma rotina que simplesmente não funciona. Quando você encontrar um problema desse tipo, desejará usar algumas das ferramentas que o Visual Basic oferece para depuração.

À medida que trabalhar com as várias ferramentas de depuração, você descobrirá que alguns dos botões da barra de ferramentas Debug do Visual Basic representam atalhos simplificadores. Esta barra de ferramentas não é visível como a barra de ferramentas padrão, mas você pode torná-la visível selecionando-a no menu View/Toolbars. A Figura 9.1 identifica os botões da barra de ferramentas Debug.

 

Figura 9.1 Os botões da barra de ferramentas Debug.

 

A Janela Immediate

Como você já sabe, o pressionamento de Ctrl-Break em qualquer instante durante a execução de seu programa interromperá o aplicativo e ativará a janela Immediate. Se um certo procedimento estiver sendo processado quando o programa for interrompido, você verá também a janela de código desse procedimento. Nesse ponto, você pode introduzir e processar instruções de Visual Basic na janela Immediate . Cada instrução pode conter apenas uma linha. A instrução é executada dentro da janela Immediate ao se pressionar a tecla Enter. O código na janela de código não se altera.

Normalmente, você desejará apenas imprimir o valor de variáveis e expressões que lhe interessam. Porém, pode-se ir muito além disso. De fato, você pode executar quase todas as instruções de programação do Visual Basic; por exemplo, pode modificar uma variável ou executar um procedimento dentro da janela Immediate . Observe, no entanto, que você pode apenas modificar variáveis locais, parâmetros do procedimento atual e variáveis em nível de módulo ou públicas. Não é possível examinar ou alterar variáveis locais a outros procedimentos que não o atual. É possível também modificar o valor de quaisquer propriedades que possam ser alteradas em tempo de execução.

Como uma demonstração, crie um novo projeto que contenha apenas um botão de comando. Inclua o procedimento geral DoStuff e o procedimento Click para o botão de comando, conforme mostrado pela Figura 9.2.

Figura 9.2 O código de programa para o aplicativo Girar os Polegares.

Pressione F5 para iniciar o aplicativo. Dê um clique no botão de comando e pressione Ctrl-Break para que o Visual Basic pare o aplicativo e exiba a janela de código, que será semelhante à mostrada na Figura 9.3. (São boas as chances de que o programa seja interrompido na rotina DoStuff; caso isso não aconteça, pressione F5 para reiniciar o programa e tente interrompê-lo novamente.)

Figura 9.3 A janela de código de um programa interrompido.

Na janela de código mostrada na Figura 9.3, a linha Next B aparece em destaque, porque é a próxima instrução a ser executada pelo Visual Basic. Na janela Immediate, você poderia introduzir a instrução Print B (ou apenas ? B) para ver quantas vezes a instrução For realizou o laço. Você poderia introduzir Print A para ver o valor atual de A. Entretanto, não poderia digitar Print C ou Print D para examinar as outras variáveis do programa, mesmo que elas contenham valores, pois a janela Immediate está limitada ao escopo do procedimento executado no momento. Se introduzir as instruções Print C ou Print D, o Visual Basic assumirá que você está apenas usando variáveis não-declaradas no procedimento atual e imprimirá uma linha em branco. Você tem acesso a todas as variáveis e propriedades de escopo global ou em nível de módulo, tornando possível a execução de instruções como Print Command1.Caption e Print Form1.Height.

Para modificar uma propriedade ou uma variável na janela Immediate , você deve usar as mesmas instruções e expressões que são usadas em um programa. Por exemplo, você pode diminuir o tamanho da janela de um form, executando a instrução Form1.Height = Form1.Height/2. Ou pode executar qualquer subprocedimento, ou método, introduzindo o seu nome. Por exemplo, ao introduzir a instrução Print, você está chamando o método Print do objeto representado pela janela Immediate (um objeto chamado Debug). Você não está limitado aos procedimentos internos do Visual Basic; pode também executar qualquer um dos procedimentos que escreveu.

Expressões de Vigilância

Quando você deseja apenas examinar o valor de uma variável, o Visual Basic oferece uma técnica rápida que dispensa o uso de instruções Print. Estando no modo de interrupção (Break Mode), posicione o cursor do mouse sobre o nome de uma variável na janela de código - tente fazer isso com a variável B do procedimento DoStuff - e você verá o valor da variável aparecer num pequeno retângulo próximo a ela.

Você também pode incluir uma expressão vigiada na janela Watch , para poder acompanhar o seu valor todas as vezes que interromper a execução do programa. Para incluir uma expressão selecionada, dê um clique com o botão direito do mouse sobre o nome da variável na janela de código e selecione Add Watch no menu apresentado, ou escolha a opção Add Watch do menu Debug. Na caixa de diálogo Add Watch, mostrada na Figura 9.4, dê um clique no botão OK para fazer com que a expressão vigiada selecionada apareça na janela Watch.

Figura 9.4 A caixa de diálogo Add Watch.

Você pode também incluir uma expressão a ser vigiada na janela Watch sem antes ter de selecioná-la. Basta digitar a expressão desejada diretamente na caixa de texto da caixa de diálogo Add Watch. O quadro Context da caixa de diálogo permite-lhe especificar o procedimento ou módulo no qual as variáveis de sua expressão estão definidas - isso poderá ser necessário, por exemplo, quando você tiver duas variáveis com o mesmo nome, uma em nível de form e outra local. (Discutiremos o quadro Watch Type da caixa de diálogo mais adiante.)

A Figura 9.5 apresenta o aspecto da janela Watch após a inclusão de duas expressões que serão vigiadas. Essas expressões exibem a variável D no procedimento Command1_Click e a variável B no procedimento DoStuff.

Figura 9.5 A janela Watch com expressões que serão vigiadas.

Se você quiser editar ou remover uma expressão vigiada, incluída na janela Watch, selecione a opção Edit Watch do menu Debug e faça as modificações necessárias na caixa de diálogo Edit Watch que será exibida.

A Arvore de Chamadas (Onde Estou?)

No exemplo simples da seção anterior (o aplicativo Girar os Polegares), era bem evidente o que aconteceria quando o programa fosse interrompido. Porém, num aplicativo mais complexo, a seqüência de eventos pode não ser tão clara assim. Nesse caso, você pode selecionar a opção Call Stack do menu View para produzir uma caixa de diálogo que mostre as chamadas a procedimentos ativos no programa.

A Figura 9.6 mostra a caixa de diálogo Call Stack (Pilha de Chamadas) para o programa Girar os Polegares. A primeira linha da caixa de diálogo exibe o procedimento atual - neste caso, o procedimento DoStuff, que está no módulo Form1. Esse procedimento foi chamado a partir do procedimento de evento Command1_Click, também contido no módulo Form1. O rastreamento das chamadas termina aqui, pois a chamada ao procedimento Click foi disparada por um evento gerado pelo usuário. Em um programa complexo, a caixa de diálogo Call Stack poderia exibir muitas entradas, indicando o aninhamento das chamadas a procedimentos. Você pode dar um clique duplo em qualquer uma das entradas (ou selecionar uma entrada e dar um clique no botão Show) para exibir o código do procedimento em questão.

Figura 9.6 A árvore de chamadas para um programa interrompido.

Pontos de Interrupção (Break Points) e Instruções Stop

Ao pressionar Ctrl-Break para interromper o programa Girar os Polegares, você não tem muito controle sobre o ponto onde o programa será interrompido. Porém, o Visual Basic permitirá que você marque explicitamente uma ou mais instruções como pontos de interrupção, locais nos quais a execução do programa parará, dando-lhe a oportunidade de vasculhar o programa para tentar diagnosticar os seus problemas. Você pode configurar pontos de interrupção antes de executar o programa ou então após interromper a sua execução. Para configurar um ponto de interrupção, abra a janela de código para o procedimento desejado e dê um clique na região acinzentada na lateral da janela de código à esquerda da instrução onde a execução deverá parar. Ou então selecione a instrução e pressione F9 ou escolha a opção Toggle BreakPoint do menu Debug. O Visual Basic colocará a linha destacada para indicar a presença de um ponto de interrupção.

Para remover um ponto de interrupção, basta refazer um dos procedimentos acima para a instrução selecionada. Caso tenham sido estabelecidos vários pontos de interrupção, pode-se selecionar a opção Clear All BreakPoints (remover todos os pontos de interrupção) do menu Debug para eliminá-los de uma única vez.

Pode-se conseguir o mesmo efeito de estabelecimento de pontos de interrupção, incluindo-se instruções Stop. Essa técnica não é tão conveniente quanto o uso de pontos de interrupção, pois exige um esforço maior de codificação. Porém, com pontos de interrupção, o Visual Basic interrompe o programa toda vez que a execução atingir um desses pontos. Com o uso de instruções Stop, você pode ser muito mais específico, assegurando que o programa parará apenas em determinadas condições. Por exemplo, o fragmento de código a seguir interromperia seu programa após ser executado 10 vezes e somente se o valor da variável A fosse menor do que 0.

Static ContadorParada As Integer

ContadorParada = ContadorParada + 1

If ContadorParada > 10 And A < 0 Then

Stop

End If

Após seu programa ser interrompido, seja por meio de pontos de interrupção, seja por instruções Stop, você pode fazer a execução prosseguir, pressionando F5 ou escolhendo a opção Continue do menu Run do Visual Basic. Se tiver usado instruções Stop, precisará lembrar-se de removê-las do programa. Os pontos de interrupção estarão ativos apenas para a sessão atual do Visual Basic.

O uso de instruções Stop pode ser descrito como uma técnica invasiva - ou seja, e preciso modificar fisicamente a estrutura de seu programa. Outro exemplo de técnica invasiva é a escrita na janela Immediate (Debug) em um capítulo anterior. A instrução Debug.Print seguida por uma expressão faz com que o valor da expressão seja escrito na janela Immediate , sem causar qualquer interrupção do programa. A colocação de algumas poucas instruções desse tipo ao longo de programas "doentes" poderá ajudá-lo a descobrir o ponto onde os problemas começam a ocorrer. Entre os usos mais comuns estão a impressão do nome dos procedimentos que começaram a ser executados, e a exibição do valor de certas variáveis.

Apesar das técnicas invasivas permitirem-lhe executar operações mais sofisticadas, as técnicas não-invasivas, como pontos de interrupção, são preferíveis, pois evitam que você deixe dentro do programa "paciente" o equivalente a uma esponja ou a um bisturi. Se você se esquecesse de remover uma instrução Stop de um procedimento raramente executado antes de compilar o programa, você (ou, pior ainda, um cliente que estivesse usando o seu programa) poderia ter um choque quando a mensagem "Stop statement encountered" ("Encontrada instrução Stop") aparecesse no meio de um aplicativo, encerrando-o imediatamente e enviando toda e qualquer informação para a terra do nunca.

Pontos de Vigilância

Há uma outra técnica não-invasiva, chamada de ponto de vigilância, que avisa ao Visual Basic para interromper o programa quando uma condição particular for atingida (em contraste com o ponto de interrupção, que especifica a parada quando uma determinada linha de código for alcançada) ou quando o valor de uma expressão se modificar.

Para assinalar um ponto de vigilância, destaque a expressão especifica no seu código e escolha a opção Add Watch do menu Debug, ou selecione a opção Add Watch primeiro e depois digite a expressão na caixa de texto da caixa de diálogo Add Watch. Nessa caixa de diálogo (mostrada anteriormente na Figura 9.4), mova-se para a seção Watch Type (tipo de vigilância), selecione o botão de opção marcado como Break When Value is True (parar quando a expressão for verdadeira) e dê um clique no botão OK. O Visual Basic incluirá a expressão na janela Immediate . Se desejar que o programa pare quando o valor da expressão se modificar, deve selecionar o botão de opção marcado como Break When Value Changes (parar quando a expressão se modificar) na caixa de diálogo Add Watch.

Em qualquer um dos casos, ao ser retomada a execução do programa, o Visual Basic: avaliará a expressão que será vigiada após a execução de cada instrução, interrompendo-o quando ocorrer a condição especificada.

Pontos de vigilância são ferramentas muito poderosas, mas têm um lado negativo. Apesar de não-invasivos, os pontos de vigilância tornam mais lenta a execução de seu programa, pois as expressões que serão vigiadas precisam ser continuamente testadas. A melhor técnica é o uso combinado de pontos de interrupção com pontos de vigilância. Assinale um ponto de interrupção na posição do programa onde você suspeita que algo esteja errado. O programa pode ser executado a toda velocidade até aquele ponto. A partir daí, você pode ativar um ou mais pontos de vigilância e continuar a execução mais lentamente.

Passo a Passo

Outra técnica de depuração não-invasiva é a passo a passo, que lhe permite executar o seu programa uma instrução de cada vez. Ela é essencialmente equivalente à configuração de um ponto de interrupção, uma instrução adiante da posição atual, executando a instrução do momento e removendo o ponto de interrupção. Quando você caminha passo a passo através das instruções de seu programa, consegue examinar o efeito da execução de cada instrução.

O percurso passo a passo é controlado pela tecla F8 (ou pela opção Step Into do menu Debug, muito embora seja bem mais prático usar a tecla de função). Você pode iniciar a execução passo a passo, quando o seu programa não está sendo processado. Cada vez que F8 for pressionado, o Visual Basic executará uma instrução e o destaque marcando a próxima linha na janela de código avançará. Se a instrução executada contiver uma chamada a um procedimento escrito pelo usuário, a janela de código modifica-se e o destaque aparece ao redor da primeira linha executável do procedimento recém-chamado. Caso seja executada uma instrução que contenha mais de uma chamada, você percorrerá passo a passo cada um dos procedimentos, na ordem em que forem chamados. Por exemplo, considere o programa mostrado na Figura 9.7. (Os números de referência do lado esquerdo foram incluídos apenas para identificar as várias linhas do programa.)

Se você processar esse programa com um ponto de interrupção assinalado na linha 3 (A = 4), o destaque aparecerá inicialmente na linha 3. Quando você pressiona F8 para iniciar a execução passo a passo, a caixa avança para as linhas 4, 8, 9, 12, 13 e 5. (Já que as linhas 7 e 11 são vistas como declarações, e não como linhas executáveis, a ferramenta de depuração irá saltá-las. Se você configurar um ponto de interrupção em uma declaração, quando o programa for interrompido, o destaque aparecerá na próxima linha executável.)

Figura 9.7 Código de programa demonstrando a execução passo a passo.

Se você estiver executando um programa passo a passo e atingir um procedimento que já tenha sido suficientemente depurado, pode evitar a sua execução passo a passo. Se mantiver a tecla Shift pressionada enquanto pressiona F8, ou se der um clique no submenu Step Over do menu Debug, o Visual Basic fará a execução da instrução apenas no procedimento atual, executando as chamadas a outros procedimentos como se fossem instruções simples. Se usar Shift-F8 para percorrer o programa mostrado na Figura 9.7, você irá mover-se da linha 3 para a linha 4 e para a linha 5. O Visual Basic executará as linhas de 7 até 9 e de 11 até 13, evitando que você tenha de percorrer os dois procedimentos de função, instrução a instrução, pois você tem certeza de que estão corretos. Caso você chegue a entrar num dos procedimentos chamados e queira sair da execução passo a passo dentro do procedimento, pode clicar na opção Step Out do menu Debug ou pressionar a combinação de teclas Ctrl-Shift-F8. Nesse caso, todas as instruções restantes do procedimento atual serão executadas e a execução só será interrompida na posição imediatamente seguinte à sua chamada.

Você tem liberdade para alternar entre as três formas de percurso passo a passo, instrução a instrução, procedimento a procedimento ou entrada no procedimento e saída com Step Out, durante uma sessão de depuração. Observe que um ponto de interrupção colocado dentro de um procedimento causará a parada da execução, mesmo que você esteja fazendo o percurso procedimento a procedimento.

Experimente essas técnicas com o programa Girar os Polegares mostrado na Figura 9.2. Em primeiro lugar, use F9 para assinalar um ponto de interrupção na instrução Next D no procedimento Command1_Click. Pressione F5 para processar o programa e dê um clique no botão de comando para atingir o ponto de interrupção.

Pressione F9 novamente para remover o ponto de interrupção. Depois, mantendo a tecia Shift pressionada, pressione F8 algumas vezes. Você permanecerá no procedimento Command1_Click (ainda que observe uma pequena pausa enquanto o procedimento DoStuff está sendo processado). Quando você retornar à instrução Next D, pressione F8 duas vezes sem usar a tecla Shift. Esses dois passos simples irão colocá-lo dentro do procedimento DoStuff, onde você pode continuar a técnica passo a passo.

Finalmente temos a janela Locals, que pode ser exibida selecionando Locals Window no menu View. Essa janela lhe permite acessar para consulta e modificação o conteúdo de todas as variáveis e objetos que sejam visíveis ao procedimento atual. As variáveis e seus valores são apresentados numa estrutura de árvore. No caso de objetos, as suas propriedades e variáveis membro podem ser acessadas expandindo o nó em que são apresentados.

Estratégias de Depuração

Normalmente, é bem fácil localizar a origem de um problema em um programa; com freqüência, é evidente que tudo está funcionando, com exceção de um botão ou de um certo cálculo. Você pode então aplicar a técnica clássica de granulosidade decrescente. O termo granulosidade refere-se ao tamanho dos blocos de programa que precisam ser executados. Você pode iniciar usando pontos de interrupção que lhe permitam executar grandes pedaços do programa sem interrupção. À medida que se aproximar do ponto onde as coisas começam a dar errado, você poderia mudar para passo a passo procedimento por procedimento e então para passo a passo instrução por instrução, até determinar o ponto exato onde acontece o erro.

Evidentemente, o parágrafo anterior assume com otimismo que a origem de seus problemas seja uma simples instrução. Freqüentemente isso não é assim. Você pode descobrir que fez suposições sobre o valor de variáveis ou sobre a entrada feita pelo usuário que simplesmente não são verdadeiras, e isso irá forçá-lo a reescrever algumas partes de seu programa. Como há uma forte tendência a assumir tais suposições como verdadeiras durante a sua sessão de depuração, pode-se tornar muito difícil determinar o que está dando errado. Em momentos como esses, você poderá verificar essas suposições, criando a codificação necessária para tal. Por exemplo, se você assume que um certo parâmetro jamais terá um valor menor do que 10 ou maior do que 50, pode inserir a seguinte codificação no início do procedimento que contém o tal parâmetro:

lf Param < 10 Or Param > 50 Then

Debug.Print "Suposição inválida sobre a variável 'Param.' "

Stop

End If

Muito embora se trate de uma técnica invasiva, a codificação para validação de suposições, por vezes, pode ajudá-lo a encontrar os bugs mais rapidamente do que o uso das técnicas não-invasivas, especialmente no caso de programas longos ou complexos.

Finalmente, naquelas ocasiões em que você não tem a menor idéia do que está dando errado, pode recorrer à técnica Elmer Fudd, segundo a qual você aplica uma matriz de 12 verdades e mentiras para "despachar o programa para qualquer lugar" se ele não começar a funcionar direito. Entretanto, por mais satisfação que isso possa trazer, seria altamente improdutivo.

Há uma outra alternativa. Você pode usar uma pesquisa binária, que é uma variação da abordagem de granulosidade decrescente. A estratégia de uma pesquisa binária é igual à usada em jogos de adivinhação. Se o seu adversário escolhe um número de 1 a 100, você consegue determinar o número com no máximo oito tentativas. A sua primeira tentativa deve sempre ser 50. Seu oponente deve dizer se você acertou, se está acima ou abaixo. Se estiver acima você deve tentar 25; se abaixo, 75. A cada tentativa, você elimina metade das alternativas restantes.

Similarmente, quando você possui um programa complexo e não tem qualquer idéia de onde procurar o problema, coloque um ponto de interrupção na metade do aplicativo. Ao ser atingida a interrupção, examine o valor das variáveis mais importantes. Se parecer que está tudo bem, coloque o próximo ponto de interrupção no ponto médio entre a posição atual e o final do programa. Do contrário, coloque o ponto de interrupção no ponto médio entre o inicio do programa e o ponto atual e reinicie o processamento do programa. Essa técnica deve conduzi-lo mais rapidamente à vizinhança do problema, permitindo que então você mude para a técnica de depuração passo a passo, ou outra técnica mais apropriada.

Não hesite em utilizar os recursos de depuração do Visual Basic para testar suas teorias sobre o que está acontecendo de errado com o seu programa. Por exemplo, se você descobrir que esqueceu de incrementar uma variável, não abandone o processo de depuração para corrigir o programa. Use a janela Immediate para configurar a variável com o valor que imagina estar correto e deixe a execução do programa continuar. Por vezes, você perceberá que o que parece ser a origem do problema na realidade é um efeito colateral do problema real.

Pode-se usar ainda as ferramentas de depuração para fazer experiências com o fluxo de controle de seu programa. Digamos que você tenha interrompido seu programa em um certo ponto dentro de um procedimento e tenha concluído que está faltando uma instrução If para saltar algumas linhas. Você pode configurar a próxima instrução a ser executada, dando um clique nela e então selecionando a opção Set Next Statement do menu Debug. Você pode selecionar qualquer instrução dentro do procedimento do momento, mesmo que seja anterior à instrução atual, porém não pode especificar uma instrução de outro procedimento como a próxima instrução a ser executada.

Tratamento de Erros

Até agora, este capítulo concentrou-se nos erros de programação que podem causar uma falha do aplicativo ou o retorno de resultados inválidos. Outra classe de problemas, chamada de erros de execução (runtime errors), também podem fazer com que seu programa venha a falhar. Os erros de execução quase sempre provêm de condições que você não pode controlar, tais como falta de memória ou de espaço em disco, um engano por parte do usuário ao tentar abrir um arquivo que já foi aberto por outros aplicativos e assim por diante. Outros erros de execução são bugs, indicativos de erros de lógica no seu programa, tais como indexação além do limite dimensionado para uma matriz.

Quando ocorre um erro de execução, o Visual Basic normalmente exibe uma caixa de diálogo de mensagem e encerra o aplicativo. No entanto, você pode obter o controle sobre o tratamento desses erros por meio da codificação de algumas rotinas. Essa técnica, chamada de captura de erros, permite ao seu programa detectar e possivelmente contornar o problema, ou pelo menos encerrar a execução do programa mais amigavelmente. Você estabelece seu controle sobre o sistema, habilitando a captura de erros. Quando você escreve um procedimento que captura erros, sua estrutura geral deve ser semelhante a esta:

Sub declaração

[Instruções]

On Error GoTo Rótulo

[Instruções]

Exit Sub

Rótulo:

Codificação para tratamento do erro

End Sub

A instrução On Error GoTo Rótulo, onde Rótulo identifica o código para tratamento de erros, habilita a captura de erros. Se ocorrer um erro de execução na instrução que se segue à instrução On Error GoTo Rótulo, o controle será transferido imediatamente para o código de tratamento de erros, identificado por Rótulo. Rótulo poderá ser qualquer identificador que você venha a escolher e, quando usado para marcar um determinado local do seu código, deve terminar com dois-pontos (:).

Para desabilitar a captura de erros mais adiante, dentro do mesmo procedimento, você pode usar a instrução On Error GoTo 0. A partir desse ponto, qualquer erro de execução que venha a ocorrer será tratado diretamente pelo Visual Basic, e não pela rotina de tratamento de erros dentro de seu procedimento. Essa capacidade de ativar e desativar a captura de erros será útil se apenas um pequena parte de seu código estiver propensa a conter erros de execução.

A captura de erros ficará ativa apenas no procedimento que contiver a instrução On Error GoTo Rótulo. Quando um procedimento se encerra, a captura de erros retorna à rotina que originalmente chamou o procedimento. Caso essa rotina não contenha manipulador de erros, a captura de erros será desativada.

Uma vez que a execução de seu programa seja movida para a rotina de tratamento de erros de um procedimento, você pode testar o valor de retorno da função Err para descobrir a origem do erro. Err retorna um inteiro indicando o tipo de erro - erro 7, por exemplo, indica que você extrapolou a memória disponível; erro 53 indica que o programa não consegue encontrar o arquivo designado; e assim por diante. A lista completa dos código de erros aparece no sistema de ajuda on-line do Visual Basic e em seu manual de referência.

Evidentemente, o seu manipulador de erros não será obrigado a tratar de todos os tipos de erros. O erro 53, por exemplo, poderá ocorrer somente quando você tentar acessar um arquivo. Se seus procedimentos não têm acesso a arquivos, você não precisa tratar o erro 53.

Após determinar o tipo de erro que ocorreu, você tem quatro alternativas. A mais simples é devolver o erro para o Visual Basic. Você consegue isso com a instrução Error. A instrução Error requer apenas um argumento e provoca imediatamente o erro de execução designado pelo argumento. A inclusão da instrução Error Err no final de sua codificação para tratamento de erros fará com que o Visual Basic trate os erros que você não quis testar.

As outras três alternativas envolvem a retomada da execução do programa. A inclusão da instrução Resume em sua rotina de tratamento de erros fará com que a execução seja retomada após a correção do erro. Você pode usar as seguintes variações:

 

Figura 9.8

 

Considere o código de programa mostrado na Figura 9.9, que gera um erro quando tenta fazer uma divisão por zero.

 

Figura 9.9 Código de programa que inclui tratamento de erros.

 

Quando você executar esse procedimento, as instruções serão processadas seqüencialmente até atingir a linha 6. Nesse ponto, será disparado o erro 11 (divisão por zero) e o controle do programa passará para a linha 10. A codificação de tratamento de erro assinalará o valor 2 para a variável XX e a instrução Resume fará com que a linha 6 seja processada novamente. Desta vez, a expressão não gerará erro. A instrução 7 imprimirá o valor 5, e o procedimento será encerrado.

Caso fosse usada a instrução Resume Next na linha 12, o programa continuaria na linha 7, que imprimiria o valor 10 (valor inalterado de YY), pois a linha 6 não teria sido executada corretamente. Finalmente, se a instrução na linha 12 fosse Resume ISair, a execução seria retomada na linha 8, provocando o encerramento da rotina sem imprimir qualquer valor.

É importante observar que a instrução Resume aplica-se somente ao procedimento no qual aparece. Tomemos o exemplo da Figura 9.9, e modifiquemos o código para incluir dois procedimentos, conforme mostrado na Figura 9.10, onde aparece o tratamento de erros com múltiplos procedimentos.

 

Figura 9.10 Código de programa que demonstra o tratamento de erros com múltiplos procedimentos.

Ao executar esse código, você verá a seguinte saída:

Início

Entrando

Entrando

5

Saindo

Feito

Se você usasse uma instrução Resume Next em vez de Resume, a seguinte saída seria produzida:

Início

Entrando

Feito

Em ambos os casos, a rotina de tratamento de erros faz a execução ser retomada dentro do procedimento que contém o manipulador de erros, e não na instrução que realmente causou o erro no procedimento Bugged. Se você deseja que seu programa seja capaz de retomar a execução normal dentro do procedimento Bugged, terá de incluir uma rotina de tratamento de erros nesse procedimento.

 

 

Localize a linha exata do erro com RabJump.