Procedure in Procedure

[Metschu]

Hallo zusammen,

auf der Suche nach einer XML-Komponente wurde mehrfach der xml Paraser empfohlen.
In dem Beispielcode ist unter anderem eine Procedure innerhalb einer Procedure:

Delphi-Quellcode:

PROCEDURE TFrmMain.FillTree;

  PROCEDURE ScanElement (Parent : TTreeNode);
  VAR
    Node : TTreeNode;
    Strg : AnsiString;
    EN   : TElementNode;

  BEGIN
    WHILE XmlParser.Scan DO BEGIN
      Node := NIL;
      CASE XmlParser.CurPartType OF
        ptXmlProlog : BEGIN
                        Node := TrvDoc.Items.AddChild (Parent, '<?xml?>');
                        Node.ImageIndex := Img_Prolog;
                        EN := TElementNode.Create (StrSFPas (XmlParser.CurStart, XmlParser.CurFinal), NIL);
                        Node.Data := EN;
                      END;
{noch weitere CASE abfragen...}
     END;
      IF Node <> NIL THEN
        Node.SelectedIndex := Node.ImageIndex;
      END;
  END;

BEGIN
  TrvDoc.Items.BeginUpdate;
  TrvDoc.Items.Clear;
  XmlParser.Normalize := TRUE;
  XmlParser.StartScan;

  ScanElement (NIL);

  TrvDoc.Items.EndUpdate;
END;

Was hat dies für einen Hintergrund?
"ScanElement" wird ja nur einmal aufgerufen.

Danke schonmal.

Gruß

Torsten

[Nersgatt]

Übersichtlichkeit. Durch die Namensgebung der 2. Procedure wird automatisch dokumentiert, was dieser Codeabschnitt bewirkt.
Technisch hätte man es auch direkt in die 1. Procedure schreiben können.

[bernau]

Übersichtlich ist das Beispiel gar nicht. In dem Besipiel macht es m.E. keinen Sinn. Es macht Sinn, wenn die entsprechende Procedure mehrfach in der umschliessenden Procedure aufgerufen wird.

[bernau]

Ach ja. Sollten in der äusseren Procedure Variablen deklariert sein, kann die innere Procedure darauf zugreifen. Ist im Besispiel aber nicht gegeben.

[vagtler]

Zitat:

Zitat von bernau (Beitrag 1254107)

Übersichtlich ist das Beispiel gar nicht. [...]

Das ist Ansichtssache.

[bernau]

Stimmt. Ansichtssache ;-)

Aber in dem Fall hätte man die innere Procedure komplett auslagern können, da ja nicht auf Variablen der äusseren Procedure zurückgegriffen wird.

[EWeiss]

Zitat:

Zitat von bernau (Beitrag 1254116)

Stimmt. Ansichtssache ;-)

Aber in dem Fall hätte man die innere Procedure komplett auslagern können, da ja nicht auf Variablen der äusseren Procedure zurückgegriffen wird.

Welchen sinn macht das ?
Wenn diese Procedure im gesamten Code nur einmal verwendet wird.
Irgendwie unlogisch oder?

gruss

[Nersgatt]

Das mit der Übersichtlichkeit ist natürlich immer subjektiv.

Man hätte sich hier auch den Parameter sparen können, da offensichtlich immer NIL übergeben wird. Es sieht so aus, als wäre die innere Procedure ein Relikt aus Zeiten, wo der Aufruf noch öfter (mit verschiedenen Parameterwerten) vorkam.

Trotzdem kann die Aufteilung schon Übersichtlichkeit bringen (wie gesagt, die Funktion des Codeabschnitts ergibt sich hier schon aus dem Namen).
Ich persönlich nutze diese Procedure-in-Procedure-Konstrukte recht selten. Hier in dem Fall hätte ich auch eine private procedure von TfrmMain davon gemacht.

[himitsu]

Eventuell war in der Procedur früher mal ein rekursiver Code, der dann später zu diesem iterativen Code umgebaut wurde?
Und der Einfachheit halber ließ man den Code dann ganz einfach dort.

Zitat:

Zitat von bernau (Beitrag 1254116)

Aber in dem Fall hätte man die innere Procedure komplett auslagern können, da ja nicht auf Variablen der äusseren Procedure zurückgegriffen wird.

Auslagern gut und schön, aber dann auch bitte richtig!
Also XmlParser und TrvDoc gehören gefälligst in den Parametern übergeben.

[Dejan Vu]

Variante 1;

Delphi-Quellcode:

Procedure Something();
Begin
  if Foobar>23 then Stuff:=Bar;
  For bar in foo do  begin
  ...
  end;
end;

Variante 2:

Delphi-Quellcode:

Procedure Something();
  Procedure SetStuff();...
  Procedure ProcessAllFoos();...
Begin
  SetStuff();
  ProcessAllFoos();;
end;

Variante 2 *dokumentiert* ohne Kommentar. Prozeduren sind ja nicht nur dazu da, um Redundanz zu vermeiden, sondern sollen die Lösung (also den Code) in Teillösungen unterteilen. Im Idealfall so, das jede Teillösung (aka Prozedur, Methode) nur eine einzige Aufgabe hat (=> Clean Code).

Die Sache mit den lokalen Prozeduren ist ein Überbleibsel aus der Vor-OOP-Zeit. Mittlerweile würde man das eher als private Methode umsetzen.