Om håndtering av unntak i Delphi unntakshåndtering

Her er et interessant faktum: Nei kode er feilfri - faktisk er noen koder fulle av "feil" med vilje.

Hva er en feil i et program? En feil er en feil kodet løsning på et problem. Slike er logiske feil som kan føre til gale funksjonsresultater der alt virker pent satt sammen, men resultatet av applikasjonen er fullstendig ubrukelig. Med logiske feil, en applikasjon kanskje eller ikke kan slutte å fungere.

Unntak kan inkludere feil i koden din der du prøver å dele tall med null, eller du prøver å bruke frigitte minneblokker eller prøve å gi gale parametere til en funksjon. Et unntak i en applikasjon er imidlertid ikke alltid en feil.

Unntak er spesielle forhold som krever spesiell håndtering. Når en feiltilstand oppstår, gir programmet et unntak.

Du (som programskribent) vil håndtere unntak for å gjøre søknaden din mer feilutsatt og for å svare på den eksepsjonelle tilstanden.

I de fleste tilfeller vil du finne deg selv å være applikasjonsforfatter og også bibliotekforfatter. Så du må vite hvordan du kan gjøre unntak (fra biblioteket ditt) og hvordan du håndterer dem (fra applikasjonen).

Artikkelen om håndteringsfeil og unntak gir noen grunnleggende retningslinjer for hvordan du kan beskytte mot feil ved bruk av try / unntatt / slutt og prøve / endelig / slutt beskyttede blokker for å svare på eller håndtere eksepsjonelle forhold.

En enkel prøve / unntatt beskyttelsesblokker ser ut som:

prøve
ThisFunctionMightRaiseAnException ();
unntatt// håndtere alle unntak hevet i ThisFunctionMightRaiseAnException () her
slutt;

ThisFunctionMightRaiseAnException kan ha i sin implementering en kodelinje som

raise Unntak. Opprett ('spesiell tilstand!');

Unntaket er en spesiell klasse (en av få uten T foran navnet) definert i sysutils.pas-enheten. SysUtils-enheten definerer flere spesielle formål unntak etterkommere (og skaper dermed et hierarki av unntaksklasser) som ERangeError, EDivByZero, EIntOverflow, etc.

I de fleste tilfeller er unntakene du vil håndtere i den beskyttede forsøket / unntatt blokken, ikke unntaket (base) -klasse, men av noen spesiell unntaksklasse for unntak definert i VCL eller i biblioteket du er ved hjelp av.

For å fange og håndtere en unntakstype vil du konstruere en "on type_of_exception do" unntakshåndterer. "Unntaket gjør" ligner omtrent på den klassiske saksuttalelsen:

prøve
ThisFunctionMightRaiseAnException;
excepton EZeroDivide dobegin// noe når du deler med nullslutt;
på EIntOverflow dobegin// noe når det er for stor heltalberegningslutt;
elsebegin// noe når andre unntakstyper hevesslutt;
slutt;

Legg merke til at den andre delen vil fange alle (andre) unntak, inkludert de du ikke vet noe om. Generelt sett skal koden din bare håndtere unntak du faktisk vet hvordan du skal håndtere og forventer å bli kastet.

Du bør heller ikke "spise" et unntak:

prøve
ThisFunctionMightRaiseAnException;
unntatt
slutt;

Å spise unntaket betyr at du ikke vet hvordan du skal håndtere unntaket, eller at du ikke vil at brukere skal se unntaket eller noe derimellom.

Når du håndterer unntaket og du trenger mer data fra det (det er tross alt et eksempel på en klasse), heller bare den typen unntak du kan gjøre:

prøve
ThisFunctionMightRaiseAnException;
excepton E: Unntak dobegin
ShowMessage (E.Message);
slutt;
slutt;

"E" i "E: Unntak" er en midlertidig unntaksvariabel av typen spesifisert etter kolonnetegnet (i eksemplet ovenfor basen unntaksklasse). Ved hjelp av E kan du lese (eller skrive) verdier til unntaksobjektet, for eksempel få eller angi Melding-egenskapen.

Har du lagt merke til hvordan unntak faktisk er tilfeller av en klasse som stiger fra unntaket? Hevingsøkkelordet kaster et eksempel på en unntaksklasse. Det du oppretter (unntaksforekomsten er et objekt), også du trenger å frigjøre. Hvis du (som biblioteksforfatter) oppretter en forekomst, vil applikasjonsbrukeren frigjøre den?

Her er Delphi magi: Håndtering av et unntak ødelegger unntaksobjektet automatisk. Dette betyr at når du skriver koden i "unntak / slutt" -blokk, vil den frigjøre unntaksminnet.

Så hva skjer hvis ThisFunctionMightRaiseAnException faktisk reiser et unntak og du ikke takler det (dette er ikke det samme som å "spise" den)?

Når et ubehandlet unntak kastes i koden, håndterer Delphi igjen unntaket på magisk vis ved å vise feildialogen til brukeren. I de fleste tilfeller vil denne dialogboksen ikke gi nok data til at brukeren (og til slutt du) kan forstå årsaken til unntaket.

Dette styres av Delphis meldingssløyfe på toppnivå hvor alle unntak behandles av det globale applikasjonsobjektet og dets HandleException-metode.

For å håndtere unntak globalt, og vise din egen mer brukervennlige dialog, kan du skrive kode for TApplicationEvents. OnException-hendelsesbehandler.

Merk at det globale applikasjonsobjektet er definert i skjema-enheten. TApplicationEvents er en komponent du kan bruke til å avskjære hendelsene til det globale applikasjonsobjektet.