"forward" von Units mit Record/Class Helpern

[Rollo62]

Hallo zusammen,

mangels besserer Bezeichnung nenne ich das was ich möchte mal "Unit forwarding",
und zwar aus einem Base-Unit die Klassen in ein Interface-Unit übernehmen und re-deklarieren.
So das nur noch das Interface-Unit in der Anwendung benutzt werden muss.


Base-Unit

Delphi-Quellcode:

interface Pages.Types;

type
    TPage_Elem        = (Eins, Zwei);             // Hier werden diese Klassen etc. definiert
    TPage_Elem_Helper = record helper for TPage_Elem;  // Hier kann es Helper geben
       procedure DoDomething;
    end;

...
...

Interface-Unit

Delphi-Quellcode:

interface Pages;

Uses
    Pages.Types  // Hier sind Klassen, Records, Enums, etc. definiert, s.o.
  ;

type
    TPage_Elem        = Pages.Types.TPage_Elem;         // Hier werden diese Klassen etc. ge-forwared
    TPage_Elem_Helper = Pages.Types.TPage_Elem_Helper;  // das möchte ich auch mit Helpern so machen

und dann nur per Interface nutzen, während die Implementation in den Base-Units bleibt.

Delphi-Quellcode:

interface Main_Unit;

Uses
  Pages;  // die Typen aus den Base-Units werden hier ge-forwarded und sind direkt nutzbar

...
...

procedure Test;
begin

  LElem := TPage_Elem.Eins;  // Alles OK, kann ich benutzen mit Klassen, Records, Enums ...
  LElem.DoSomething   // <-- ! Hier kann es nicht kompiliert werden, die Base-Units werden benötigt

end;

Gibt es da einen Trick wie man auch die Helper aus den Base-Units "forwarden" kann ?
Oder ist sowas etwa ein schlechter Stil ?

Rollo

[Der schöne Günther]

Spaßig dass es die Code Completion sogar vorschlägt, der Compiler aber dann aber nicht kann


Ich sehe den Gefallen nicht denn man sich mit diesem "Forwarding" tut. Um sich eine Zeile im uses zu sparen?

[Rollo62]

Bei viel Modularisierung ist es eben nicht nur eine Unit, sondern vielleicht auch 5.
Das macht sich schon bemerkbar

[Aviator]

Wenn du so etwas schon machen willst und es dann auch noch Interface nennst, dann solltest du am besten auch mit Interfaces arbeiten

Dann sprichst du das Thema Modularisierung an. Da bietet es sich auch gleich im Zusammenhang mit Interfaces an, mit Factories zu arbeiten.

Schau dir das Thema mal an. Damit erreichst du eigentlich das was du willst und es wird noch modularer.

Edit:
Oh Moment ... du sprichst hier von Records
Naja vielleicht bringt es dir trotzdem was oder du kannst auf Klassen umstellen. (Die benutze ich zumindest lieber als Records)

[Der schöne Günther]

Zitat von Rollo62:

Bei viel Modularisierung ist es eben nicht nur eine Unit, sondern vielleicht auch 5.
Das macht sich schon bemerkbar

Ich sehe trotzdem nicht dass das ein Vorteil ist. Damit versteckt man nur vor sich selber wovor die aktuelle Unit grade abhängig ist.


PS: Ich kann es schon etwas verstehen wenn man den Helper für ein Enum vermisst, darum geht es ja eigentlich. Entweder inkludierst du die Unit wo der Helper drinsteckt, oder du verabschiedest dich ganz vom Enum und nimmst stattdessen gleich einen Record der ein Enum kapselt. Deinem Record kannst du nun Methoden verpassen und brauchst keinen Helper mehr. Durch Operator-Überladung kannst du dein altes Enum diesem Record zuweisen und umgekehrt...

Delphi-Quellcode:

type
   TMyEnum = (uno, dos, tres);

   TMyEnumStruct = record
      Value: TMyEnum;
      function Next(): TMyEnumStruct;
      function Prev(): TMyEnumStruct;
      function ToString(): String;
      class operator Implicit(a: TMyEnumStruct): TMyEnum;
      class operator Implicit(a: TMyEnum): TMyEnumStruct;
   end;

und

Delphi-Quellcode:

procedure p();
var
   myEnum: TMyEnumStruct;
begin
   myEnum := TMyEnum.dos;
   myEnum := myEnum.Next();

   WriteLn( myEnum.ToString() );
end;

[Rollo62]

@Aviator
Ich nenne es Interface weil auch eins drin ist.
Die Helper sind Hilfs-Typen für das Interface.

@Günther
Mir ging es eigentlich im Wesentlichen um die Helper dabei.
Die funktionieren nämlich weder bei Enum noch den anderen Sprachelementen.

Ich möchte das Konzept so ja auch erstmal für mich einführen.
Ich nenne das für mich "API", in der Hoffnung das ich komplexere Dinge simpel in der Anwenung zusammenfassen kann.

Also z.B. Pages API die mir Alles für die Seitenverwaltung mitliefert, auch die Unterklassen, etc.
Es geht mir um eine einfache Lernkurve dabei, wo man eben nicht Alle 5 Unter-Units genau kennen muss.

Ich habe es bisher auch anders gelöst, und spiele gerade mit diesem Konzept etwas herum,
und bin nur verwundert das ausgerechnet die Helper sich nicht "forwarden" lassen,
der Rest der Elemente aber schon.
Liegts an mir, oder an ... ?

Rollo

[Uwe Raabe]

Zitat von Rollo62:

und bin nur verwundert das ausgerechnet die Helper sich nicht "forwarden" lassen,

Das liegt an der Art wie Helper implementiert sind. Man kann das in etwa so betrachten wie globale Prozeduren und Funktionen.

Aus

Delphi-Quellcode:

type
    TPage_Elem_Helper = record helper for TPage_Elem
       procedure DoSomething;
    end;

wird dann intern so etwas in der Art

Delphi-Quellcode:

procedure TPage_Elem_Helper_DoSomething(var Self: TPage_Elem);

Damit der Compiler das auflösen kann, muss die Unit auch im uses erscheinen.

Es ist halt so, daß Helper nicht überall dort einsetzbar sind, wo andere Konstrukte funktionieren. Dies hier ist eben ein solcher Fall.