Autor Beitrag
Ares
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 128



BeitragVerfasst: Mo 29.10.07 17:08 
Hallo!

Ich bastel gerade an dem Grundgerüst eines neuen Programms. Man könnte es vielleicht Architektur nennen, aber ganz so ausgereift ist es noch nicht. Die Idee ist, dass ich im Prinzip die verschiedenen Aufgaben im Programmfluss auf verschiedene Klassen aufteile.

Hierbei gibt es eine Hierachie mit zwei Stufen:
Auf der unteren Stufe gibt es für jede Aufgabe einen eigenen "Manager", also z.B. eine "OptionsManager" der die Programmoptionen liest, schreibt und verwaltet oder einen "TuSonstWasManager" der sonst was tut. Darüber steht der "ProgrammManager", der einige globale Werte speichert und alle anderen Dinge regelt. Er erzeugt dann die untergeordneten Manager, ruft diese auf, etc.

In der Unit die den ProgrammManager implementiert müssen also alle Units der "SubManager" referenziert werden.

Gleichzeitig sollen die SubManager aber auch Zugriff auf die Werte des ProgrammManagers haben (z.B. "Unter welchem Registrypfad sind die Optionen gespeichert?"). Hierfür sollen die SubManager mit einer Referen auf den ProgrammManager erstellen:

ausblenden Delphi-Quelltext
1:
SubManager.Create(Parent: ProgrammManager)					


In diesem Fall müssen aber die Units die die SubManager implementieren die Unit des ProgrammManagers referenzieren. Genau hier kommte es zu einem zirkulären Bezug!


Wie kann ich dies möglichst elegant lösen?

Ich könnte natürlich jedem SubManager die benötigten Werte per Parameter übergeben. Dies wäre aber ziemlich umständlich. Die Werte sind ja zentral im ProgrammManager vorhanden, von dort sollten sich die SubManager diese also auch holen können.

Wenn man alle Klassen in eine Unit schreibt tritt das Problem ebenfalls nicht auf. Dies wäre aber ziemlich unübersichtlich.

Hat jemand eine Idee wie man dieses Konzept umsetzten könnte und gleichzeitig das Problem mit dem zirkulären Bezug elegant umgeht?

Besten Dank
Ares
Tilo
ontopic starontopic starontopic starontopic starofftopic starofftopic starofftopic starofftopic star
Beiträge: 1098
Erhaltene Danke: 13

Win7 geg. WInXP oder sogar Win98
Rad2007
BeitragVerfasst: Mo 29.10.07 17:20 
Meine Vorschlag: Vererbung.
Du erstellst eine Hauptklasse(Ursprungsklasse). Diese Klass braucht nur ganz rudimentäre Funktionen (eventuell nur virtual?).
Von dieser Hauptklasse leitest Du dann alle anderen SubKlassen. Eine Subklasse ist dein Hauptmanger und eine andere Klasse der Submanager.

Die Unit der Ursprungsklasse kannst Du in jede Unit einbinden ohne das es zu einem Zirkelschluss kommt.

Jedes Object kennt die anderen relevanten Objecte dann nur als Objekte vom Typ der Ursprungsklasse.
Das dürfte helfen.
Habe jetzt eine Übung.
Gruß Tilo
Ares Threadstarter
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starontopic star
Beiträge: 128



BeitragVerfasst: Di 30.10.07 12:28 
user profile iconTilo hat folgendes geschrieben:
Meine Vorschlag: Vererbung.
Du erstellst eine Hauptklasse(Ursprungsklasse). Diese Klass braucht nur ganz rudimentäre Funktionen (eventuell nur virtual?).
Von dieser Hauptklasse leitest Du dann alle anderen SubKlassen. Eine Subklasse ist dein Hauptmanger und eine andere Klasse der Submanager.


Mmh, das wird wohl nicht funktionieren. Die Verschiedenen Manager haben eigentlich nur recht wenig gemeinsam. Natürlich könnte man die Gemeinsamkeiten ein eine Oberklasse stecken, aber der Zugriff auf die einzelnen Funktionen der verschiedenen Manager kann nicht nur über gemeinsame Schnittstelle der Oberklasse laufen. Der OptionsManager hat z.B. Daten die nur der OptionsManager hat. Damit der ProgrammManager auf diese zugreifen kann muss er den OptionsManager referenzieren und nicht eine allgemeine Oberklasse...

Ich mach nochmal kurz deutlich was ich machen will:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
Unit_A
...
uses Unit_B; // Notwendig für TOptionsManager...

type
  TProgrammManager = class(TObject)
  private
    FOptionsManager: TOptionsManager;
    FRegistryPfad: String;
  public
    constructor Create;
    RegistryPfad: String read FRegistryPfad;
  end;
...
constructor TProgrammManager.Create;
begin
  FOptionsManager := TOptionsManager.Create;
  FOptionsManager.LiesOptionen;
end;


ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
Unit B
...
uses Unit_A; // Notwendig für TProgrammManager ...

type
  TOptionsManager= class(TObject)
  private
    FParrent: TProgrammManager;
  public
    constructor Create(aParrent: TProgrammManager);
    procedure LiesOptionen;
  end;
...
constructor TOptionsManager.Create(aParrent: TProgrammManager);
begin
  FParrent := aParrent;
end;

procedure TOptionsManager.LiesOptionen;
begin
  OpenRegistryPath(FParrent.RegistryPfad);
  ...
end;


Wenn ich hier mit Vererbung arbeiten würde, müssten beide Klassen von TAllgemeinerManager abstammen. Diese Klasse müsste dann sowohl eine Methode LiesOptionen, also auch eine Eigenschaft RegistryPfad habe und wäre damit nicht sonderlich allgemein...

Noch Ideen?

Besten Dank
Ares
noidic
ontopic starontopic starontopic starontopic starontopic starontopic starofftopic starofftopic star
Beiträge: 851

Win 2000 Win XP Vista
D7 Ent, SharpDevelop 2.2
BeitragVerfasst: Di 30.10.07 12:59 
Vielleicht kommst du da mit Interfaces weitet. Baust dir ein Interface mit einer Funktion für jede Eigenschaft, welche die Submanager aus dem Hautptmanager brauchen und greifst in den Submanagern nur über das Interface zu. Der Hauptmanager implementiert das Interface.

Zu Interfaces solltest du hier im Forum und in der Hilfe ausreichend was finden, falls du damit noch nicht gearbeitet hast.

_________________
Bravery calls my name in the sound of the wind in the night...
delfiphan
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2684
Erhaltene Danke: 32



BeitragVerfasst: Fr 02.11.07 00:22 
user profile iconAres hat folgendes geschrieben:
Noch Ideen?


Idee 1: Du könntest du z.B. eine zusätzliche Klasse haben, welche die Registry-Information trägt. Die Klasse wäre in einer dritten Unit deklariert. TProgrammManager würde dem TOptionsManager dann das Objekt mit der Registry-Information übergeben.

Idee 2: Du könntest einen vereinfachten TProgrammManager in einer Drittunit haben, welcher noch kein TOptionsManager enthält, jedoch den RegistryPfad.

Idee 3: Die Registry-Information über ein Event oder Callback abfragen, welches TProgrammManager bei TOptionManager hinterlegt.

Idee 4: In einer Drittunit ein Interface mit der Methode GetRegistryPfad arbeiten, welches TProgrammManager implementiert.

Idee 5: TOptionsManager nimmt TObject-Parent entgegen. Im Implementationsteil kann TOptionsManager den Parent dann casten.

Idee 6: FOptionsManager in TProgrammManager ist TObject. Im Implementationsteil wird jedoch das "richtige" TOptionsManager instanziert und bei Bedarf gecastet.

Idee 7: In Unit_A im interface-Teil TProgrammManager ohne FOptionManager. Im Implementationsteil eine von TProgrammManager abgeleitete Klasse erstellen mit FOptionManager.

Zweifellos nicht alle Ideen gleich gut ;)