Fem tip til håndteringsfejl i VBA

En professionel applikation indeholder altid tilstrækkelige fejlhåndteringsrutiner til at fange uventede fejl. Undertiden betyder den rigtige håndtering, at brugeren aldrig ved, at fejlen er opstået. I det mindste skal fejlhåndteringsrutiner løse problemet, dele passende information om, hvad brugeren skal gøre næste, og forlade græsset (hvis det er absolut nødvendigt) grådigt. Du lægger en stor indsats i at skrive de procedurer, der kører dine tilpassede applikationer. Hvorfor lade en runtime-fejl ødelægge det hele? Ved at anvende et par bedste fremgangsmåder kan du forbedre fejlhåndtering.

1: Bekræft og konfigurer fejlindstillinger

Før du gør noget, skal du kontrollere indstillingerne for fejlfangning. VBA er via Visual Basic Editor (VBE) fleksibel og giver dig mulighed for at bestemme, hvordan det reagerer på fejl. For at få adgang til disse indstillinger (vist i figur A ) skal du i VBE vælge Valg i menuen Funktioner og klikke på fanen Generelt:
  • Afbryd alle fejl : Stopper ved enhver fejl, også fejl efter en CV- sætning igen.
  • Afbryd uhåndterede fejl: Stopper for uhåndterede fejl, men stopper på linjen, der kalder klassen (i klassemoduler) snarere end linjen med fejlen, hvilket kan være problematisk under fejlsøgning.
  • Indbrud i klassemoduler : Stop med den faktiske fejl (kodelinje), men fungerer ikke som forventet med Err.Raise, som genererer en egen fejl.

Figur A

Vælg den mest passende indstilling af fejlhåndtering.
Velinformerede brugere kan ændre denne indstilling, så jeg anbefaler, at du inkluderer en procedure, der ligner den i Liste A, til din applikations opstartrutine.

Liste A

Function SetErrorTrappingOption() 
  'Set Error Trapping to Break on Unhandled Errors. 
  Application.SetOption "Error Trapping", 2 
 End Function 

2: Hver procedure kræver fejlhåndtering

Lejlighedsvis skriver du en enkel procedure, hvor der ikke er noget potentiale for fejl. Men de fleste procedurer bør have en rutine til fejlhåndtering, selvom den er så grundlæggende som denne:

Private | Public Function | Sub procedurename ()

On Error GoTo errHandler

...

  Exit Function | Sub 
 errHandler: 
  MsgBox "Error " & Err.Number & ": " & Err.Description & " in " & _ 
  VBE.ActiveCodePane.CodeModule, vbOKOnly, "Error" 
 End Sub 

Dette er fejlhåndtering på sit enkleste. Ovenstående behandler viser fejlnummeret, en beskrivelse og modulets navn. Nogle udviklere foretrækker at kontrollere exit ved hjælp af CV til at pege på en exit-procedure, hvilket er nyttigt, når du udfører specifikke vedligeholdelses- eller oprydningsopgaver, før de afslutter (se Tip # 5).

I udviklingsstadiet kan denne grundlæggende handler være nyttig (eller ikke; se tip # 3). Senere i testfasen kan du forbedre den grundlæggende rutine for at håndtere fejlen eller fortælle brugeren, hvad han skal gøre næste.

3: Kontrol af fejlfangning under udvikling

Jeg har lige bedt dig om at tilføje en generisk fejlhåndteringsrutine til enhver procedure, hvilket kan være nyttigt under udviklingen. Nogle udviklere synes dog, at disse generiske rutiner er irriterende. Her er hvorfor. Når fejlfinderen støder på en fejl, sker der en af ​​to ting:

  • Hvis der ikke er nogen fejlhåndteringsrutine, stopper debuggeren ved den krænkende kodelinje, hvilket kan være praktisk.
  • Når der er en rutine til fejlhåndtering, debuggeren udfører det, hvilket kan gøre debugging vanskeligere.

Hvis du er i lejren, der finder fejlhåndtering i udviklingsfasen for invasiv, kan du tilføje en generisk handler og kommentere den, indtil du er klar til det. Det kan dog være lidt smertefuldt. Alternativt kan du glemme kommentaren og i stedet stole på en konstant. Angiv specifikt en global boolsk konstant som følger:

 Public Const gEnableErrorHandling As Boolean = False 

Kør derefter hvert opkald til fejlhåndteringsrutinen med konstanten som denne:

 If gEnableErrorHandling Then On Error GoTo errHandler 

Så længe konstanten er falsk, springer koden fejlhåndteringsrutinen. Når du er klar til at aktivere fejlhåndtering, skal du blot nulstille konstanten til True. Den konstante metode kan også være på dig, fordi du er nødt til at køre hvert fejlhåndteringsopkald. I sidste ende er den rute, du tager, ikke så vigtig som at kende alternativerne, og hvordan man implementerer dem korrekt.

4: Hæmmer fejl

Undertiden er den bedste måde at håndtere en fejl at ignorere den. Denne situation opstår, når du vil udføre en opgave ved at vide, at den muligvis genererer en fejl, og ofte er fejlen det, du er ude efter! For eksempel, hvis en efterfølgende opgave er afhængig af en bestemt fil, skal du teste for filens eksistens, før du udfører denne opgave. Hvis udsagnet fejl, ved du, at filen ikke er tilgængelig, og du kan medtage kode, der tager passende handling.

Ganske vist får denne opsætning nogle udviklere til at krybe - du introducerer med vilje en fejl i din kode. På den anden side, korrekt håndteret, kan det være en meget mere effektiv rute end alternative løsninger.

For at ignorere en fejl skal du gå foran erklæringen med sætningen Genoptag næste som følger:

 On Error Resume Next 

Denne erklæring gør det muligt for programmet at fortsætte til den næste kodelinie og ignorere fejlen fuldstændigt. Kort sagt deaktiverer Genoptag næste fejlhåndtering fra den linje frem (inden for proceduren). Det er den lette del, men du er ikke færdig. Hver gang du bruger Genoptag Næste skal du nulstille fejlhåndtering ved hjælp af følgende sætning:

 On Error GoTo 0 

GoTo 0 deaktiverer aktiveret fejlhåndtering i den aktuelle procedure og nulstiller den til Intet - det er den tekniske forklaring. Kort sagt, Genoptager Next springer en fejl over, og GoTo 0 fortæller fejlfinderen at stoppe springende fejl.

Sørg for at indsætte GoTo 0- sætningen så tidligt som muligt. Du vil ikke maskere andre fejl.

5: Håndter udgangen

Når fejlhåndteringsrutinen er færdig med sin opgave, skal du sørge for at rute kontrol korrekt:

  • Ved at afslutte proceduren
  • Ved at returnere kontrol til proceduren

Begge strategier er passende; kodens formål dikterer dit valg.

Tip nr. 2 indeholder den enkleste fejlhåndteringsrutine. Det viser oplysninger om fejlen og afslutter proceduren. Du kan kontrollere denne exit ved at inkludere en exit rutine som denne:

 Private | Public Function | Sub procedurename () 
  On Error GoTo errHandler 
  ... 
 exitHere: 
  ... 
 errHandler: 
  MsgBox "Error " & Err.Number & ": " & Err.Description & " in " & _ 
  VBE.ActiveCodePane.CodeModule, vbOKOnly, "Error" 
 Resume exitHere 
 End Sub 

Når fejlhåndteringsrutinen er færdig, dirigerer Genoptag exitHere- udsagnet strømmen til exitHere . Du har ikke altid brug for så meget kontrol, men det er standard praksis i mere robuste procedurer.

Begge ovenstående rutiner afslutter proceduren, men nogle gange vil du fortsætte med at udføre proceduren - ikke afslutte den. Specifikt vender Genoptag tilbage kontrol til den linje, der genererede fejlen. Resume Next returnerer kontrol til linjen umiddelbart efter den kodelinje, der genererede fejlen. Forskellen er vigtig. Hvis din fejlhåndteringsrutine rettede fejlen, kan det være den passende handling at vende tilbage til den linje, der genererede fejlen. Derefter igen, at springe over den linje kan være den passende handling. At gå ud af en fejl på denne måde kan være kompliceret, så vær forsigtig og sørg for at teste dine rutiner grundigt.


© Copyright 2020 | mobilegn.com