Delphi: Globale Behandlung von Fehlermeldungen (Exceptions)

Exceptions lassen sich in Delphi und Lazarus einfach mit der Hilfe von Try-Except-Blöcken abfangen und behandeln. Passiert beispielsweise in dem folgenden Code ein Fehler zwischen Try und Except, wird der Code hinter dem Except ausgeführt und wir können verhindern, dass der Nutzer eine Standard-Fehlermeldung angezeigt bekommt und uns stattdessen eine eigene Fehlerbehandlung implementieren:

try
   //Code
except
   on E:Exception do begin 
     // wird im Falle eines Fehlers ausgeführt
   end; 
end;

Wünscht man sich allerdings eine globale Fehlerbehandlung aller Exceptions, die irgendwo im Programm vorkommen, stößt Try-Except schnell an seine Grenzen. Schließlich wäre es zu umständlich, um jeden Code des Programms ein Try-Except-Block zu schreiben, um den Fehler von dort aus an eine zentrale Funktion weiterzuleiten.

Aus diesem Grund möchte ich euch in diesem Tutorial eine Möglichkeit zeigen, wie ihr alle Fehler, die in eurem Programm geschehen in einer Prozedur abfangen könnt, um die Fehler dort zentral zu behandeln.

Globale Fehlerbehandlung

Wir nennen unsere Prozedur GlobalExceptionHandler und deklarieren sie wie folgt unter "public":

public
  procedure GlobalExceptionHandler(Sender: TObject; E: Exception);

Unsere Anwendung (Application) kennt das Ereignis "OnException", das bei einer Exception ausgelöst wird. Wir möchten dieses Ereignis mit unserer eigenen Prozedur überschreiben und schreiben daher folgende Zuweisung in das OnCreate:

procedure TForm1.FormCreate(Sender: TObject);
begin
  // Code für Delphi:
  Application.OnException := GlobalExceptionHandler;

  // Code für Lazarus:
  Application.OnException := @GlobalExceptionHandler;
end;

Je nachdem ob wir Delphi oder Lazarus für die Programmierung verwenden, müssen wir die Zuweisung der Prozedur entweder mit einem vorangestellten "@"-Zeichen (Lazarus) oder ohne (Delphi) vornehmen.

Schließlich müssen wir nur noch unsere Prozedur GlobalExceptionHandler definieren:

procedure TForm1.GlobalExceptionHandler(Sender: TObject; E: Exception);
begin
  // das passiert, wenn ein Fehler auftritt

  // wir können zum Beispiel eine Meldung anzeigen...
  ShowMessage(E.Message);

  // ...oder die Fehlermeldungen mit Datum und Zeit in einem Memo sammeln
  Memo1.Lines.Add(FormatDateTime('yyyy-mm-dd hh:nn:ss', now) + ' ' + E.Message);
end;

Diese Prozedur wird nun immer dann aufgerufen, wenn irgendwo in unserem Programm ein Fehler auftritt, der eine Exception auslöst.

Innerhalb der Prozedur können wir noch weitere Informationen über den Fehler sammeln. In E.ClassName steht zum Beispiel die Art der Exception, in E.Message die Fehlermeldung. Damit lässt sich für jede Fehlerart ein anderer Vorgang definieren oder wir können zum Beispiel auch E.ClassName und E.Message in einen Error-Log schreiben und speichern. In unserem Beispiel zeigen wir die Fehlermeldung über einen ShowMessage-Dialog an und protokollieren die Fehler mit Datum und Uhrzeit in einem Memo-Feld.

Eigene Exceptions erzeugen

Natürlich funktioniert diese Art der globalen Fehlerbehandlung nur für die Fehler innerhalb unseres Programms, die auch eine Exception auslösen (also automatisch nur für Fehler wie Division durch Null, Access Violations und so weiter). Wenn wir auch Fehler, die in unserem eigenen Code vorkommen können, in unserem globalen Exception-Handler behandeln möchten, können wir einfach eine eigene Exception auslösen. Das funktioniert folgendermaßen:

raise Exception.Create('Beliebiger Text der Fehlermeldung');  

Wenn wir diese Codezeile ausführen, wird eine Exception erzeugt, die dann an unsere Exception-Handler-Prozedur weitergegeben wird und dort ausgewertet werden kann. Wir können Exception.Create() einen beliebigen Text als Fehlermeldung übergeben, zum Beispiel nähere Informationen zu dem Fehler, wie welche fehlerhaften Werte oder Nutzereingaben zu dem Problem geführt haben oder welche Vorkommnisse ansonsten für die Exception verantwortlich waren.