Exception innerhalb von Schleifen

[Dezipaitor]

Ich habe die folgende Empfehlung gefunden:
http://www.delphi-treff.de/backstage...e/katalog/256/

Delphi-Quellcode:

procedure TMyClass.DoSomething;
var i: Integer;
begin
  for i := 0 to High(FMyField) do
  begin
    try
      FMyField[i].DoIt;
    except
      ShowMessage('Invalid: ' +
                   IntToStr(i));
    end;
  end;
end;

Damit die For-Schleife ohne eine interne Exception-Behandlung auskommt, die die Schleife verlangsamt,
wird dieses empfohlen.

Delphi-Quellcode:

procedure TMyClass.DoSomethingIntern(
  StartIndex: Integer);
var  ExceptionRaised: Boolean;
begin
  ExceptionRaised := False;
  try
    for i := StartIndex to High(FMyField) do
    begin
      StartIndex := i;
      FMyField[i].DoIt;
    end;
  except
    ExceptionRaised := True;
    ShowMessage('Invalid: ' +
      IntToStr(i));
  end;
  if ExceptionRaised then
    DoSomethingIntern(StartIndex + 1);
end;

procedure TMyClass.DoSomething;
begin
  DoSomethingIntern(0);
end;

Meiner Meinung jedoch, kommt hier ein anderes Problem hinzu.
Die Prozedur wird rekursiv aufgerufen. Bei einer großen Menge von Fehlern, kann es leicht zu einem Stackoverflow kommen. Der Stack wird zu klein.

Wäre das eine Lösung?

Delphi-Quellcode:

procedure TMyClass.DoSomething;
var  i : Integer;
label RestartLoop;
begin

  i := 0;
RestartLoop:
  try
    while i <= High(FMyField) do
    begin
      StartIndex := i;
      FMyField[i].DoIt;
      Inc(i);
    end;
  except
    ExceptionRaised := True;
    ShowMessage('Invalid: ' +
      IntToStr(i));
    Inc(i);
  end;
  if i <= High(FMyField) then
    goto RestartLoop;
end;

[sirius]

Dann mache doch besser aus dem goto-Konstrukt ein repeat-until.

[Dax]

Warum machst du eigentlich solche Gedanken um die Kosten für einen Exception Handler? Wenn deine Methode DoIt nicht grade kürzer ist als eine Zeile, sind die Kosten vernachlässigbar.

[Dezipaitor]

Zitat:

Zitat von sirius

Dann mache doch besser aus dem goto-Konstrukt ein repeat-until.

Dann wären wir wieder beim zweiten Beispiel, worin ein try/except innerhalb einer Schleife den Ablauf verlangsamt.

Zitat:

Zitat von Dax

Warum machst du eigentlich solche Gedanken um die Kosten für einen Exception Handler? Wenn deine Methode DoIt nicht grade kürzer ist als eine Zeile, sind die Kosten vernachlässigbar.

Exception Handling ist ein rieser Aufwand. Wenn es darum geht, sehr sehr viele Daten zu überprüfen und zu konvertieren (z.B. mit StrToInt), dann kann es leicht zu Problemen kommen.
Letztendlich kann nur ein Profiler wirklich aussagen, wo die Engstellen sind. Aber in einigen Fällen kann sich das schon lohnen. Daher ist Gedanken machen immer besser als alles zu vernachlässigen.
Zudem: Wie soll Quelltext kürzer als eine Zeile sein?

Oh - ich habs:

Delphi-Quellcode:

begin
end;

0 Zeilen effektiver Code. :bouncing4:

[mkinzler]

Zitat:

Exception Handling ist ein rieser Aufwand. Wenn es darum geht, sehr sehr viele Daten zu überprüfen und zu konvertieren (z.B. mit StrToInt), dann kann es leicht zu Problemen kommen.

Außerdem ist dann der Weg der sicheren Konventierung (z.B. TryStrToInt() oder Val()) vorzuziehen.

[Dezipaitor]

Man kann nicht immer bestimmen, welche Funktionen innerhalb von fremden Funktionen aufgerufen werden, die bestimmte Funktionen aufrufen, welche andere Funktionen aufrufen, die wiederum andere Funktionen aufrufen, welche....

[Dax]

Wie kostspielig der Handler genau sind, kann ich natürlich nicht aus dem Stand für alle Situationen sagen - aber ein kleiner Test vorhin (100mio durchläufe einer Schleife, einmal mit Handler, einmal ohne, als effektiver Code jeweils ein Methodenaufruf, der (x * 3 + 42) / pi auf ein Klassenfeld berechnet) hat keine großen Unterschiede gezeigt. Wenn ich irgendwan nicht beachtet habe, bitte sagt es :)

[Dezipaitor]

Langsam sollte es werden, wenn ständig Exception fliegen - warum auch immer.

[Dax]

Ja, da ist was dran - aber da hilft es dir dann auch nix, den Exception Handler aus der Schleife herauszuhalten ;) Ich würde sogar behaupten, dass die rekursive Methode im Falle vieler Fehler langsamer ist als die iterative mit dem Handler im Schleifenkörper, vorrausgesetzt, der Stack hält die Geschichte auch aus.

[sirius]

Ob nun Repeat-until-Schleife außenrum oder Goto ist völlig egal. Schleife sieht nur besser aus.
Und wenn eine Exception fliegt, bremst das eh das Programm aus, egal bei welchem Konzept wir sind.

Die Frage besteht darin, was ist schneller wenn keine Exception fliegt. Einen Exceptionblock anzulegen sind 4 bis 5 ASM-Befehle. selbiges gilt fürs Löschen des Blockes. Also nahezu nix.