Fehlerbehandlung mit Try..Except

[mickmack]

Hallo,

ich habe mal eine Frage zur Fehlerbehandlung mit Try..Except. Leider konnte ich zu dem Problem auf dem Rest der Seite nichts fidnen. Am besten stelle ich mein Problem mal in vereinfachter Form dar:

Also ich habe ein Projekt, bestehend aus mehreren Units. Die Hauptunit ist die Unit des Hauptforms.
Um mich nun an EVA zu halten(die strikte Trennung von Eingabe-Verarbeitung-Ausgabe) habe ich mir vorgenommen, alles was mit Ausgabe zu tun hat in der Formulatunit zu erledigen, dh auch einfache Fehlermeldung. Zum Beispiel habe ich alle Dateifunktionen in einer seperaten Unit UFile gelagert. Die UFile ist Unterunit der Hauptunit. Wenn dort nun ein Fehler auftritt, erstelle ich über "raise" einen Fehler vom eigenen Typ EMyFileOpen.
Da ja alle Fehler im Endeffekt aus einem Ereignis im Hauptformular hervorgerufen werden, fange ich alle "geraisten" Fehler auch nur in der Hauptunit ab. Das klappt auch wunderbar, nur eines stört mich: Alle meine Ereignismethoden im Haupform haben ja den selben ExceptBlock. Doch leider habe ich es noch nicht geschafft, diesen in eine einzelne Funktion auszulagern. Dh immer wenn ich auf einen Fehler anders reagieren möchte, muss ich das in allen BLöcken einzelnd ändern.

Also zusammengefasst, gibt es eine Möglichkeit ExceptBlöcke in Procedure auszulagern?

Hier mal ein Bespiel wie es momentan bei mir aussieht

Delphi-Quellcode:

procedure TFrmMain.BtnFileOpenClick(Sender: TObject);
begin
  Try 
    OpenFile();
  Except
    on EMyOpenFile do showMessage('Fehler beim Oeffnen');
    on EMyReadFile do showMessage('Fehler beim Lesen');
    on EMyWriteFile do showMessage('Fehler beim Schreiben');
  end;
end;

Und hier, wie ich es mir vorstelle:

Delphi-Quellcode:

procedure ErrorHandling(parameter:T???);
begin
    on EMyOpenFile do showMessage('Fehler beim Oeffnen');
    on EMyReadFile do showMessage('Fehler beim Lesen');
    on EMyWriteFile do showMessage('Fehler beim Schreiben');
end;

procedure TFrmMain.BtnFileOpenClick(Sender: TObject);
begin
  Try 
    OpenFile();
  Except
    MyErrorHandling(parameter);
  end;
end;

Alles was ich bis jetzt probiert habe, hat zu diversen Fehlermeldungen geführt

Also erstmal Danke für die Mühe das ganze durchzulesen, aber in kürzer Form denke ich, wäre mein Problem nicht verständlich gewesen.

[mirage228]

Hi,

schau dir mal Application.OnException an. In der Delphi-Hilfe gibt es auch ein Beispiel dazu!

EDIT: Application.OnException wird nur aufgerufen, falls es keinen try..except Block gibt, falls einer vorhanden ist, wird der dortige Except-Block aufgerufen!

mfG
mirage228

[Niko]

Das müsste eigentlich so funktionieren:

Delphi-Quellcode:

procedure TFrmMain.BtnFileOpenClick(Sender: TObject);
begin
  Try
    OpenFile();
  Except
    on E: Exception do
      MyErrorHandling(E);
  end;  
end;

procedure ErrorHandling(E: Exception);
begin
  if E.ClassNameIs('EMyOpenFile') then showMessage('Fehler beim Oeffnen')
  else if E.ClassNameIs('EMyReadFile') then showMessage('Fehler beim Lesen')
  else if E.ClassNameIs('EMyWriteFile') then showMessage('Fehler beim Schreiben');
end;

[Skyruner2]

könnte man da nicht einfach case of benutzen?

also :

Delphi-Quellcode:

case E.ClassNameIs of
EMyOpenFile: showMessage('Fehler beim Oeffnen')
EMyReadFile:

usw

[Niko]

Leider nicht, denn ClassNameIs gibt keinen Typ sondern nur True oder False zurück. Außerdem ist case of nur auf Ordinaltypen anwendbar.

[choose]

Hey Mickmack,

Wenn Du ohnehin eigene Exception-Typen definierst, um unabhängig von den spezifischen SQLExceptions oder IOExceptions zu sein und abstraktare, der wirklichen Aufgabe entsprechenden Excpeptions zu werfen, dann bietet sich ein Basistyp zB

Delphi-Quellcode:

  EMyException = class(Exception)
  public
    procedure HandleError;virtual;abstract;
  end;

an, von Dem Du dann erbst und die Methode HandleError überschreibst, zB

Delphi-Quellcode:

  EMyOpenFile = class(EMyException)
  public
    procedure HandleError;override;
  end;

Der Entsprechde Try..Except-Block könnte dann so aussehen

Delphi-Quellcode:

try
  DoSth;
except
  on E:EMyException do HandleException(E);
  on E:Exception do raise EMyUnknownException.CreateChained(E);
end;

mit der Methode

Delphi-Quellcode:

procedure TMyClass.HandleException(const AnException: EMyException);
begin
  Assert(Assigned(AnException));
  AnException.HandleException;
end;

Die wirkliche Verarbeitung geschieht dann in der jeweiligen Implementierung von HandleException, also zB EMyOpenFile.HandleException, EMyReadFile.HandleException, etc. mithilfe von Polymorphie.

Etwas unglücklich an dieser Lösung ist die Tatsache, dass die wirkliche Handlung (zB der Aufruf von ShowMessage) direkt in der Klasse wäre und damit unflexibel ist. Zur Lösung empfehle ich Dir hier das sog. "Visitor Pattern [Gamma et. al.]" delphi AND visitor AND pattern.

Eine lesenswerte Serie über Exceptions (allerdings in Java) stammt von Brian Goetz, Exceptional practices, Part 1-3.

HTH