Try - except - finally

[idefix2]

Ich finde es ungeheuer irritierend, dass die Except Klausel und die finally Klausel nicht gleichzeitig zu einem Try verwendet werden können.
Wie handhabt ihr es, wenn als Folge einer Exception Aktionen erfolgen müssen, und am Schluss aufgeräumt werden muss, egal ob eine Exception aufgetreten ist oder nicht. Zwei geschachtelte Try Try ... except ... raise end finally ... end?

[Furtbichler]

Ja, warum nicht? Passiert ja nicht oft, das man in ein und derselben Routine sowohl einen Resourcenschutzblock als auch eine ordentliche Fehlerbehandlung implementiert.

[Bernhard Geyer]

Da wird man wohl diese Sprachunschönheit akzeptieren müssen und doppelt aufbauen

Delphi-Quellcode:

try
  try
  except
finally

Wäre schön wenn man das im Rahmen der LLVM-Compilers korrigieren könnte und auch

Delphi-Quellcode:

try
except
finally

wie in anderen modernen Sprachen auch schreiben könnte.

[bernau]

Habe ich mir nie gedanken drüber gemacht.

Ist ein except nicht irgendwie ein finally.

Alles was nach dem except-Block kommt, wird doch abgearbeitet, da die Fehler ja im Exceptblock abgefangen werden.

Free wird doch bei beiden Funktionen aufgerufen und somit ist doch alles schön aufgeräumt.

Delphi-Quellcode:

begin
  sl:=TStringlist.create;
  try
    EineFehlerhafteProcedure
  except
    // hier eine schöne Fehlermeldung
  end;
  sl.free;
end;

Delphi-Quellcode:

begin
  sl:=TStringlist.create;
  try
    EineFehlerhafteProcedure
  finally
    sl.free;
  end;
end;

[Bernhard Geyer]

Zitat von bernau:

Free wird doch bei beiden Funktionen aufgerufen und somit ist doch alles schön aufgeräumt.

Nein. Wenn eine weitere Exception im Exceptionblock auftritt nicht.

[bernau]

Zitat von Bernhard Geyer:

Zitat von bernau:

Free wird doch bei beiden Funktionen aufgerufen und somit ist doch alles schön aufgeräumt.

Nein. Wenn eine weitere Exception im Exceptionblock auftritt nicht.

Und wenn die weitere Exception im finallyblock auftritt? Dann schon?

[mjustin]

Zitat von Bernhard Geyer:

Zitat von bernau:

Free wird doch bei beiden Funktionen aufgerufen und somit ist doch alles schön aufgeräumt.

Nein. Wenn eine weitere Exception im Exceptionblock auftritt nicht.

Richtig, oder wenn die gefangene Exception nur protokolliert, und dann mit raise weitergegeben wird - ein nicht unübliches Vorgehen

[mjustin]

Zitat von bernau:

Zitat von Bernhard Geyer:

Zitat von bernau:

Free wird doch bei beiden Funktionen aufgerufen und somit ist doch alles schön aufgeräumt.

Nein. Wenn eine weitere Exception im Exceptionblock auftritt nicht.

Und wenn die weitere Exception im finallyblock auftritt? Dann schon?

Nur wenn die weitere Exception nach dem Free auftritt. Tritt sie vor dem Free auf, wird die Funktion mit der Exception abgebrochen, und das Free nicht ausgeführt.

[Furtbichler]

Zitat von Bernhard Geyer:

Da wird man wohl diese Sprachunschönheit akzeptieren müssen und doppelt aufbauen

Das ist Geschmackssache. In C# gehts auch nicht und das ist auch OK so (imho). Die Abstraktionsniveaus passen bei 'try-finally' und 'try..except' sowieso nicht, ergo ist es eh ein Designflaw, das in eine Methode zu packen, aber das mal nur nebenbei.

Zitat von bernau:

Ist ein except nicht irgendwie ein finally.

Wenn Du es 'falsch' angehst: Ja.
Das 'Try-Except' benötigst Du, um etwaige Ausnahmen/Fehler zu kapseln und das Abstraktionsniveau anzuheben. Allgemein sieht das so aus:

Delphi-Quellcode:

procedure TMyClass.Action();
begin
  try
    DoSomething();
  except
    on e:ESomethingException do
      raise new EActionException.Create (TranslateExpectedException(e));
    on e:Exception do
      raise new EActionException.Create (TranslateUnexpectedExpectedException(e));
  end
end;

D.h. Du fängst die Exceptions ab und übersetzt sie so, das der Aufrufer der Methode 'Action' etwas damit anfangen kann. Z.B. kapselst Du Fehlermeldungen beim Verbindungsaufbau der DB (TCP-, Named-Pipe-, Server-, Hardware-, Login- Fehler in eine abstraktere 'EActionFailed'- Exception. Denn den Aufrufer interessiert es nicht, was da hinter der Fassade vor sich geht und ob es eine EADOException, EOracleException, ETCPException, EIdException etc. ist.

Allgemein gesehen transformierst Du die Exception und reichst sie durch. In Sonderfällen, wenn z.B. die Exception einfach eine Ausnahme von der Regel ist, oder wenn die Exception 'repariert' werden kann, würdest Du die Exception nicht weiterreichen bzw. transformieren.

Damit ist klar, das dein Gleichsetzen nur in Ausnahmefällen zutreffen würde. Aus Gründen der Übersichtlichkeit würde ich jedoch *immer* ein explizites 'try-finally' umsetzen. Dann ist einfach sonnenklar, das es sich um einen resourcenschutzblock handelt.

Delphi-Quellcode:

Procedure TMyClass.Action(); // Public !
Begin
  Try
    InnerAction();
  Except
    on e:ESomethingException do
      raise new EActionException.Create (TranslateExpectedException(e));
    on e:Exception do
      raise new EActionException.Create (TranslateUnexpectedExpectedException(e));
  end
end;

Procedure TMyClass.InnerAction(); // private oder protected !!
begin
  Stuff.Acquire();
  try
    DoSomething(Stuff);
  Finally
    Stuff.Release();
  End
End;

Nun kann man in 'Action' entscheiden, ob man reparieren kann, oder nicht.
Es geht natürlich auch umgekehrt:

Delphi-Quellcode:

Procedure TMyClass.Action(); // Public !
Begin
  Stuff.Acquire();
  Try
    InnerAction(Stuff);
  Finally
    Stuff.Release();
  End
end;

Procedure TMyClass.InnerAction(Stuff : TStuff); // private oder protected !!
begin
  try
    DoSomething(Stuff);
  Except
    on e:ESomethingException do
      raise new EActionException.Create (TranslateExpectedException(e));
    on e:Exception do
      raise new EActionException.Create (TranslateUnexpectedExpectedException(e));
  end
End;

Meist wird man die erste Variante ('Unit of Work') verwenden. Bei der zweiten Variante ist ja nicht sichergestellt, das 'Stuff' korrekt initialisiert ist (das müsste ggf. sichergestellt werden). Allerdings könnte die 2. Variante bei Reparaturversuchen sinnvoll sein. Kommt immer auf den Fall an.

[jfheins]

Zitat von Furtbichler:

Das ist Geschmackssache. In C# gehts auch nicht und das ist auch OK so (imho).

kleiner Einwurf: doch, in C# gibt es soetwas. Doku: http://msdn.microsoft.com/de-de/libr...v=vs.110).aspx

Man kann auch das praktische using() in Verbindung mit try-catch benutzen, falls anwendbar.