ersetzt try..except begin..end?

[negaH]

Wir können das mal herleiten.

Wir wissen das wir uns in einem absolut logischen und abgeschlossenen System bewegen, auf einem Computer und in der Syntax der Sprache Delphi.

Delphi-Quellcode:

try
except
  on E: Exeption do
end;

was macht dieses,

on E: Exception do

mal ausgedrückt in Delphi, denn eigentlich ?

Delphi-Quellcode:

try
except
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is Klassentyp then
end;

Nun schreiben wir die Abfrage wie sie Alzaimar benutzt um

Delphi-Quellcode:

try
except  
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is EThisException then
    begin
      HandleThisException(E); 
    end;   
// 1.)
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is EThatException then
    begin
      HandleThatException(E); 
    end;   
// 2.)
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is Exception then
    begin
      HandleAnyException(E); 
    end;   
end;

Was wissen wir am Punkt 1.) ?
Wir wissen das falls die vorherige Abfrage zutreffen würde wir die Abfrage in 1.) einsparen könnten. Denn wenn E vom Typ EThisException ist dann kann sie nicht vom Typ EThatException mehr sein.

Aber stellen wir uns mal vor EThisException wäre von EThatException abgeleitet ?
Dann würde die erste Abfrage zutreffen und die bei 1.) und 2.) aber auch ?
Macht es Sinn, bzw. ist es sogar beabsichtigt das man dann zwei bzw. sogar drei Behandlungsroutinen für eine Exception ausführt ?
Meistens, ja fast immer, macht sowas keinen Sinn.

Wir können also vereinfachen und sogar eventuelle logische Fehler beseitigen.

Delphi-Quellcode:

try
except  
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is EThisException then
    begin
      HandleThisException(E); 
    end else   
      with Hole_Exception_Object_Aus_SEH in variable E do
        if E is EThatException then
        begin
          HandleThatException(E); 
        end else 
          with Hole_Exception_Object_Aus_SEH in variable E do
            if E is Exception then
            begin
              HandleAnyException(E); 
            end;   
end;

Wir kaskadieren die IF Anfragen und verkürzen so den Programablaufpfad. Der Code wird dadurch sogar noch schneller ausgeführt.

Nun stellen wir fest das die "Funktion" Hole_Exception_Object_Aus_SEH dreimalig aufrufen. Hinter jedem dieser Aufrufe versteckt sich produzierter Code, davon abgesehen ist es auch redundant.

Wir vereinfachen

Delphi-Quellcode:

try
except  
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is EThisException then
    begin
      HandleThisException(E); 
    end else   
      if E is EThatException then
      begin
        HandleThatException(E); 
      end else 
        if E is Exception then
        begin
          HandleAnyException(E); 
        end;   
end;

Wir stellen fest das die vielen begin end Blöcke überflüssige Redundanz darstellen. Das alles müssen wir beim Lesen mit den Augen erfassen, im Hirn übersetzen, und das für Nichts. Es ist demzufolge nicht explizit.

wir vereinfachen

Delphi-Quellcode:

try
except  
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is EThisException then HandleThisException(E) else   
      if E is EThatException then HandleThatException(E) else 
        if E is Exception then HandleAnyException(E); 
end;

Wir wissen das alle Exception Klassen von der Basisklasse Exception abgeleitet werden. Also ist die letzte IF Abfrage überflüssig, sie ist immer WAHR.

wir vereinfachen

Delphi-Quellcode:

try
except  
  with Hole_Exception_Object_Aus_SEH in variable E do
    if E is EThisException then HandleThisException(E) else   
      if E is EThatException then HandleThatException(E) 
        else HandleAnyException(E); 
end;

Wir haben vorher die on E: Exception do Syntax in eine logische Form gebracht die uns besser erklärt was da vor sich geht. Diesen Abstraktionsschritt machen wir rückgängig.

Delphi-Quellcode:

try
except  
  on E: Exception do
    if E is EThisException then HandleThisException(E) else   
      if E is EThatException then HandleThatException(E) 
        else HandleAnyException(E); 
end;

Wir resümieren: Das zu lösende Problem wurde in der Delphi Syntax auf ein nicht mehr reduzierbares Maß verkürzt. Jede weitere Reduktion würde die angestebte und sinnvolle Funktionalität verändern.

Anders ausgedrückt: es ist eben keine Stilfrage wie man was schreibt sondern eine logisch herleitbare und sinnvoll auf ein notweniges Maß reduzierbare Aufgabe des Programmierers. Die Explizität in unseren Sourcezeilen ist also eine logische Notwendigkeit damit wir nur das exakt umschreiben was auch minimal notwendig ist um ein Problem zu lösen. Wer als Programmierer meint er müsste aus modischen Gründen es nicht so handhaben der kann defakto eben nicht programmieren. Gut das sind harte Worte, unfair vielleicht, aber im Grunde absolut richtig. Ein guter Stil zeichnet sich also dadurch aus das er explizit ist.
Jede Weigerung es nicht so zu handhaben kann demzufolge nicht mehr auf logischen Gründen basierend untermauert werden. Es sind meistens emotionale Vorlieben, Sturheit, nicht Lernfähigkeit, aus Prinzip oder Gewohnheiten, aber garantiert nicht überlegtes Denken. Es stellt sich die Frage: Was machen den Programmierer den ganzen Tag lang ?

Gruß Hagen