Fem tips for håndteringsfeil i VBA

En profesjonell applikasjon inneholder alltid tilstrekkelige rutiner for feilhåndtering for å fange uventede feil. Noen ganger betyr riktig håndtering at brukeren aldri vet at feilen har oppstått. I det minste skal feilhåndteringsrutiner løse problemet, dele tilstrekkelig informasjon om hva brukeren skal gjøre videre og avslutte programmet (hvis absolutt nødvendig) grasiøst. Du legger mye arbeid i å skrive prosedyrene som kjører dine tilpassede applikasjoner. Hvorfor la en kjøretidsfeil ødelegge det hele? Ved å bruke noen få gode fremgangsmåter, kan du forbedre feilhåndteringen.

1: Bekreft og konfigurer feilinnstillinger

Før du gjør noe, sjekk innstillingene for feilfanging. VBA, via Visual Basic Editor (VBE), er fleksibel og lar deg bestemme hvordan den reagerer på feil. For å få tilgang til disse innstillingene (vist i figur A ), i VBE, velg Valg fra Verktøy-menyen og klikk kategorien Generelt:
  • Brudd på alle feil : Stoppes på alle feil, til og med feil etter en CV- setning.
  • Break On Unhandled Error : Stopper for ubehandlede feil, men stopper på linjen som ringer klassen (i klassemoduler) i stedet for linjen med feilen, noe som kan være problematisk under feilsøking.
  • Break In Class Modules : Stopper med den faktiske feilen (kodelinjen), men fungerer ikke som forventet med Err.Raise, som genererer en egen feil.

Figur A

Velg den mest passende innstillingen for feilhåndtering.
Velinformerte brukere kan endre denne innstillingen, så jeg anbefaler at du inkluderer en prosedyre, som ligner den i Liste A, til programmets oppstartsrutine.

Oppføring A

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

2: Hver prosedyre trenger håndtering av feil

Noen ganger skriver du en enkel prosedyre der det ikke er potensiale for feil. Men de fleste prosedyrer bør ha en feilhåndteringsrutine, selv om den er så grunnleggende 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 feilhåndtering på det enkleste. Behandleren ovenfor viser feilnummeret, en beskrivelse og modulens navn. Noen utviklere foretrekker å kontrollere avkjørselen ved å bruke Fortsett for å peke på en avkjøringsprosedyre, noe som er nyttig når du utfører spesifikke vedlikeholds- eller opprydningsoppgaver før du går ut (se tips # 5).

I utviklingsstadiet kan denne grunnleggende behandleren være nyttig (eller ikke; se tips nr. 3). Senere, i testfasen, kan du forbedre den grunnleggende rutinen for å håndtere feilen eller fortelle brukeren hva han skal gjøre videre.

3: Kontroll av feilfanging under utvikling

Jeg ba deg legge til en generell rutine for feilhåndtering til alle prosedyrer, noe som kan være nyttig under utviklingen. Noen utviklere synes imidlertid at disse generiske rutinene er irriterende. Her er grunnen. Når feilsøkeren møter en feil, skjer en av to ting:

  • Hvis det ikke er noen feilhåndteringsrutine, stopper avluseren ved den krenkende kodelinjen, noe som kan være praktisk.
  • Når det er en feilhåndteringsrutine, debuggeren kjører den, noe som kan gjøre feilsøking vanskeligere.

Hvis du er i leiren som finner feilhåndtering i utviklingsfasen for invasiv, kan du legge til en generisk håndterer og kommentere den til du er klar for det. Det kan være litt vondt. Alternativt kan du glemme kommentaren og stole på en konstant i stedet. Angi spesifikt en global boolsk konstant, som følger:

 Public Const gEnableErrorHandling As Boolean = False 

Kjør deretter hvert anrop til feilhåndteringsrutinen med konstanten, slik:

 If gEnableErrorHandling Then On Error GoTo errHandler 

Så lenge konstanten er falsk, hopper koden over feilhåndteringsrutinen. Når du er klar til å aktivere feilhåndtering, tilbakestiller du konstant til True. Den konstante metoden kan ha på seg også fordi du må kjøre alle feilhåndteringssamtaler av den. Til slutt er ruten du tar ikke så viktig som å vite alternativene og hvordan du kan implementere dem på riktig måte.

4: Hemming av feil

Noen ganger er den beste måten å håndtere en feil å ignorere den. Denne situasjonen oppstår når du vil utføre en oppgave og vite at den kan generere en feil, og ofte er feilen det du er ute etter! Hvis for eksempel en påfølgende oppgave er avhengig av en bestemt fil, bør du teste for filens eksistens før du utfører denne oppgaven. Hvis uttalelsesfeil, vet du at filen ikke er tilgjengelig, og du kan inkludere kode som iverksetter passende tiltak.

Riktignok gjør dette oppsettet at noen utviklere kryper - du introduserer med vilje en feil i koden din. På den annen side, riktig håndtert, kan det være en mye mer effektiv rute enn alternative løsninger.

For å ignorere en feil, går du foran utsagnet med fortsett neste setning, som følger:

 On Error Resume Next 

Denne uttalelsen lar programmet fortsette til neste kodelinje og ignorerer feilen totalt. Kort sagt, Resume Next deaktiverer feilhåndtering fra linjen frem (innenfor prosedyren). Det er den enkle delen, men du er ikke ferdig. Når du bruker Fortsett Neste, må du tilbakestille feilhåndtering ved å bruke følgende uttalelse:

 On Error GoTo 0 

GoTo 0 deaktiverer aktivert feilhåndtering i gjeldende prosedyre og tilbakestiller den til Ingenting - det er den tekniske forklaringen. I et nøtteskall hopper Resume Next over en feil, og GoTo 0 ber feilen om å slutte å hoppe over feil.

Sørg for å sette inn GoTo 0- setningen så tidlig som mulig. Du vil ikke maskere andre feil.

5: Håndter avkjørselen

Når feilhåndteringsrutinen er fullført, må du sørge for å rute kontrollen riktig:

  • Ved å gå ut av prosedyren
  • Ved å returnere kontrollen til prosedyren

Begge strategiene er passende; Kodens formål vil diktere valget ditt.

Tips 2 inneholder den enkleste feilhåndteringsrutinen. Den viser informasjon om feilen og avslutter prosedyren. Du kan kontrollere avkjørselen ved å inkludere en avkjøringsrutine 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 feilhåndteringsrutinen er fullført, dirigerer Fortsett exitHere- uttalelsen strømmen til exitHere . Du trenger ikke alltid så mye kontroll, men det er standard praksis i mer robuste prosedyrer.

Begge rutinene ovenfor avslutter prosedyren, men noen ganger vil du fortsette å utføre prosedyren - ikke avslutte den. Spesifikt returnerer Resume kontrollen til linjen som genererte feilen. Resume Next returnerer kontrollen til linjen umiddelbart etter kodelinjen som genererte feilen. Skillet er viktig. Hvis feilhåndteringsrutinen din rettet feilen, kan det være riktig handling å gå tilbake til linjen som genererte feilen. Så kan det hende at hoppe over den linjen kan være riktig handling. Å gå ut av en feil på denne måten kan være komplisert, så bruk forsiktighet og sørg for å teste rutinene dine grundig.


© Copyright 2020 | mobilegn.com