Laten we eerst twee rode draad voorbeeld verzinnen voor dit artikel. We gaan de grootte van een bestand bepalen (FileSize) en een bestand kopieeren (FileCopy), en gebruiken bij het laatste een dynamische buffer die natuurlijk niet groter hoeft te zijn dan de eerder bepaalde bestandsgrootte. De code om het bestand te kopieren zetten we in een aparte FileCopy routine, terwijl de aanroepende code er als volgt uit zou kunnen zien:

  var
    BronNaam, DoelNaam: String;
  begin
    write('Van: ');
    readln(BronNaam);
    write('Naar: ');
    readln(DoelNaam);
    FileCopy(BronNaam,DoelNaam);
    { maar wat nu als er iets fout ging? }
  end.

Syntax
De syntax van exceptions is gedeeltelijk 'geleend' van C++. In Delphi's ObjectPascal zijn er vier nieuwe keywords ter beschikking: raise (om een exception 'aan' te zetten), try (om een exception block binnen te gaan), except (om een exception te behandelen) en finally (om een code block toch uit te voeren nadat een exception is opgetreden).

Exception Class
We kunnen zowel een standaard (voorgedefinieerde) exception gebruiken, of onze eigen exceptions defini ren. De laatste zal afgeleid moeten worden van de exception hierarchie binnen ObjectPascal, bijvoorbeeld als volgt:

  type
    EIOException   = class(Exception);
    EFileNotFound  = class(EIOException);
    EFileCopyError = class(EIOException);

Genereren Exceptie: Raise
Met het gebruik van exceptions hoeven we niet langer foutwaarden terug te geven. We kunnen simpelweg een exception 'aan' zetten met 'raise' als er iets mis gaat. Een 'FileSize' functie zou er bijvoorbeeld als volgt uit kunnen zien:

  function FileSize(FileName: String): LongInt;
  var
    SRec: TSearchRec;
  begin
    if FindFirst(FileName,faArchive,SRec) <> 0 then { error }
      raise EFileNotFound.Create('File '+FileName+' not found')
    else
      FileSize := SRec.Size;
    FindClose(SRec)
  end {FileSize};

Afvangen Exceptie: Try
Als we een Pascal block binnen willen gaan waarbinnen we gebruik willen maken van exception handling (we willen dus in staat zijn om een exception af te vangen als er eentje aan wordt gezet - in plaats van het programma af te laten breken), dan moeten we gebruik maken van het 'try' keyword, bijvoorbeeld als volgt:

  procedure FileCopy(BronNaam, DoelNaam: String);
  const
    BufSize = 48 * 1024;
  var
    Bron,Doel: File;
    Buffer: Pointer;
    Size: Cardinal;
  begin
    try
      GetMem(Buffer,BufSize);
      Assign(Bron, BronNaam);
      Reset(Bron,1);
      Assign(Doel, DoelNaam);
      Rewrite(Doel,1);
      repeat
        BlockRead(Bron,Buffer,BufSize,Size);
        BlockWrite(Doel.Buffer,Size)
      until Size < BufSize;
      Close(Bron);
      Close(Doel);
      FreeMem(Buffer)
    end
  end {FileCopy};

Afhandelen Exceptie: Except
Teneinde een (mogelijk) gegenereerde exception af te handelen dienen we gebruik maken van het 'except' keyword:

  begin
    try
      FileSize('C:\autoexec.bat');
    except
      ShowMessage('File not found')
    end
  end.

Onderscheiden Excepties: On X do
Een probleem met bovenstaand voorbeeld is dat de boodschap 'File not found' zal worden gegenereerd voor elke mogelijk exception die op deze plaats wordt opgevangen. Voor dit kleine voorbeeld is dat geen probleem, maar voor een complexer algoritme is het noodzakelijk om onderscheid te kunnen maken tussen de verschillende soorten exceptions. Gelukkig kan dat door gebruik te maken van de "on X do" syntax:

  begin
    try
      FileSize('C:\autoexec.bat');
    except
      on EFileNotFound do
        ShowMessage('File not found')
    end
  end.

  begin
    try
      FileSize('C:\autoexec.bat');
    except
      on E.EFileNotFound do
        ShowMessage(E.Message)
    end
  end.

Nette Afsluiting: Finally
Stel dat we een stuk code hebben waarin we eerst een bepaalde hoeveelheid geheugen alloceren, en vervolgens iets gaan uitvoeren waarin exceptions kunnen optreden, om tenslotte pas het geheugen weer vrij te geven. Het zou natuurlijk vervelend zijn als er voor het eind van het try-block een exception op zou treden waardoor we het geheugen niet meer vrij zouden kunnen geven (dit is overigens een probleem met de C++ exceptions). Teneinde dit probleem op te lossen, kunnen we gebruik maken van het 'finally' keyword in een try-block:

  procedure FileCopy(BronNaam, DoelNaam: String);
  const
    BufSize = 48 * 1024;
  var
    Bron,Doel: File;
    Buffer: Pointer;
    Size: Cardinal;
  begin
    GetMem(Buffer,BufSize);
    try
      Assign(Bron, BronNaam);
      Reset(Bron,1);
      Assign(Doel, DoelNaam);
      Rewrite(Doel,1);
      repeat
        BlockRead(Bron,Buffer,BufSize,Size);
        BlockWrite(Doel.Buffer,Size)
      until Size < BufSize;
      Close(Bron);
      Close(Doel);
    finally
      FreeMem(Buffer)
    end
  end {FileCopy};

  procedure FileCopy(BronNaam, DoelNaam: String);
  var
    Bron,Doel: File;
    Buffer: Pointer;
    BufSize,Size: Cardinal;
  begin
    try
      BufSize := FileSize(BronNaam)
    except
      BufSize := 0;
      raise { re-raise the exception }
    end;
    GetMem(Buffer,BufSize);
    try
      Assign(Bron, BronNaam);
      Reset(Bron,1);
      try
        Assign(Doel, DoelNaam);
        Rewrite(Doel,1);
        try
          BlockRead(Bron,Buffer,BufSize,Size);
          if Size < BufSize then { not entire file read? }
            raise EFileCopyError.Create(
              Format('FileCopy: %d bytes read, %d expected.',[Size,BufSize]));
          BlockWrite(Doel,Buffer,BufSize,Size)
          if Size < BufSize then { not entire file written? }
            raise EFileCopyError.Create(
              Format('FileCopy: %d bytes written, %d expected.',[Size,BufSize]));
        finally
          Close(Bron);
        end;
      finally
        Close(Doel);
      end;
    finally
      FreeMem(Buffer,BufSize);
    end
  end {FileCopy};

  var
    BronNaam, DoelNaam: String;
  begin
    try
      write('Van: ');
      readln(BronNaam);
      write('Naar: ');
      readln(DoelNaam);
      FileCopy(BronNaam,DoelNaam);
    except
      on E: Exception do
        ShowMessage(E.ClassName+': '+E.Message)
    end
  end.

Conclusies
We hebben gezien dat exceptions ons in staat stellen om de foutafhandeling (het except deel) binnen het algoritme te scheiden. We kunnen ons nu weer in eerste instantie richten op hetgeen dat gedaan moet worden, en pas later op de afhandeling van de fouten en uitzonderingen. Bovendien vormen exceptions een belangrijke ondersteuning voor veilig programmeren. We zagen dat het keyword raise vooral nut kan hebben bij de bouw van (standaard)funkties waarbinnen fouten kunnen onstaan, terwijl de keywords try, except en finally met name voor de gebruikers van deze functies van belang zijn (namelijk voor de afhandeling van de opgetreden foutsituaties).

Nu we hebben gezien wat exceptions kunnen betekenen, gaan we de volgende keer dieper in op het voorkomen van fouten door gebruik te maken van assertions binnen Delphi.
Mocht iemand nog vragen, opmerkingen of suggesties hebben, dan hoor ik die het liefst via .