Try-Finally und Try-Except zusammen nutzen?

[Delphi.Narium]

Bevorzugt doppeltes Try.

Wenn möglich in Funktionen ausgelagert, die mir sagen, ob's erfolgreich war bzw. einen definierten Wert zurückgeben, mit dem ich garantiert weiter arbeiten kann.

Also ähnlich zu Deinem Beispiel mit Funktion und Var-Parametern.

Var-Parameter immer dann, wenn die Funktion mehr als einen Wert liefern muss oder im Fehlerfalle anders vorgegangen werden muss, als im Erfolgsfalle.

Also sowas:

Delphi-Quellcode:

if MeineFunktion(1..n Parameter) then begin
  // Weiterverarbeitung im Erfolgsfall.
end else begin
  // Weiterverarbeitung im Fehlerfall.
end;
// oder eben, Fehler in der Funktion werden vollständig behandelt und Rückgabewert ist für die Weiterverarbeitung geeignet.
Variabel := MeineFunktion(1..n Parameter);

In beiden Fällen gilt: Als Var-Parameter nur die, die auch verändert werden müssen, die übrigen als Const-Parameter.

Delphi-Quellcode:

function MeineFunktion(0..n Const-Parameter, 1..n Var-Parameter) : Boolean;
function MeineFunktion(1..n Const-Parameter) : BedarfsgerechterTyp;

Funtionen können als Rückgabewert ggfls. aber auch mal vom Typ "Record of wasauchimmer" sein, dann hat man zwar nur einen Rückgabewert, der kann aber als Record mehrere Werte enthalten (ist aber eher die Ausnahme, meist nur dann, wenn aus der Funktion irgendwas aufgerufen wird, was sowieso schon 'nen Record liefert.)

[Benmik]

Das wäre alles auch nach meinem Gusto (vielleicht ein bisschen außer dem doppelten Try). Angenehm zu wissen.

[Aviator]

Ich mache das auch mit einem doppelten try . Nur bin ich mir nie so sicher, wie die Reihenfolge am sinnvollsten ist.

So:

Delphi-Quellcode:

try
  obj := TObject.Create;
  try
    // Some code
  except
    // Exception handling
  end;
finally
  obj.Free;
end;

Oder doch so:

Delphi-Quellcode:

try
  obj := TObject.Create;
  try
    // Some code
  finally
    obj.Free;
  end;
except
  // Exception handling
end;

Ich würde ja fast sagen, dass die letztere Variante die sinnvollere sein müsste. Weil prinzipiell könnte es ja schon im Constructor des zu erzeugenden Objektes knallen. In der ersten Variante würde das dann nicht abgefangen werden.

Wie seht ihr das?

PS: Ich würde mir auch ein try .. except .. finally Konstrukt wie in C# wünschen.

[himitsu]

Welche Reihenfolge, das kommt drauf an, ob
erst Freigeben und dann Fehlerbehandlung, welche auch das Freigeben mit behandlet,
oder erst die Fehlerbehandlung und dann die Freigabe.

Eventuelle Speicherprobleme zuerst freigeben und dann behandlen,
aber muß man beim Behandelt auf das zugreifen, was knallte, dann Freigeben zuletzt.

Auch Sperren (CriticalSections und Datei- oder Datenbankzugriffe) meist zuerst beenden und dann z.B. den Fehlerdialog anzeigen,
weil andersrum kann es sonst schnell einen Deadlock geben.

Zitat:

Delphi-Quellcode:

try
  obj := TObject.Create;
  try
    // Some code
  except
    // Exception handling
  end;
finally
  obj.Free;
end;

Nein!

Lies dir die Compiler-Warnung durch und du weißt warum.

Delphi-Quellcode:

obj := TObject.Create;
try
  try
    // Some code
  except
    // Exception handling
  end;
finally
  obj.Free;
end;

[Aviator]

Zitat von himitsu:

Zitat:

Delphi-Quellcode:

try
  obj := TObject.Create;
  try
    // Some code
  except
    // Exception handling
  end;
finally
  obj.Free;
end;

Nein!

Lies dir die Compiler-Warnung durch und du weißt warum.

Das war leider nur ein Fehler bei der Eingabe, da ich das schnell hier im Editor gemacht habe. Dass das Create oben drüber gehört ist mir klar. Dafür brauche ich auch keine Compiler Warnung.

[Frickler]

Zitat von himitsu:

Delphi-Quellcode:

obj := TObject.Create;
try
  try
    // Some code
  except
    // Exception handling
  end;
finally
  obj.Free;
end;

Alternativ:

Delphi-Quellcode:

obj := nil;
try
  obj := TObject.Create;
  try
    // Some code
  except
    // Exception handling
  end;
finally
  obj.Free;
end;

Die Alternativversion ist vor allem sinnvoll, wenns mehrere Objekte sind und man nicht ein try..finally pro Objekt habe will:

Delphi-Quellcode:

obj1 := nil;
obj2 := nil;
obj3 := nil;
try
  obj1 := TObject.Create;
  obj2 := TObject.Create;
  obj3 := TObject.Create;
  try
    // Some code
  except
    // Exception handling
  end;
finally
  obj1.Free;
  obj2.Free;
  obj3.Free;
end;

statt

Delphi-Quellcode:

obj1 := TObject.Create;
try
  obj2 := TObject.Create;
  try
    obj3 := TObject.Create;
    try
      try
        // Some code
      except
        // Exception handling
      end;
    finally
      obj3.Free;
    end;
  finally
    obj2.Free;
  end;
finally
  obj1.Free;
end;

[himitsu]

Zitat:

Delphi-Quellcode:

finally
  obj1.Free;
  obj2.Free;
  obj3.Free;
end;

Sowas aber auch nur, wenn man im Normallfall sicherstellen kann, dass es beim Freigeben nicht knallt.