Trick um "überkreuzenden Bezug" von Units zu umgehen ?

[dizzy]

Genau das will er ja nicht machen.

Imho ist die einzige saubere Lösung der Umweg über eine 3. Unit die nur die Deklaraktionen enthält.

Zitat:

Zitat von stoxx

da geht natürlich nicht, da man dort ja wieder den überkreuzenden bezug von Unit1/Unit3 und umgekehrt hat.

Das stimmt nicht, da du aus Unit3 die anderen beiden ja garnicht zu referenzieren brauchst.

Delphi-Quellcode:

unit Unit3;
.
.
type
  TClass2 = class;
  TClass1 = class
    p: TClass2;
  end;
  TClass2 = class
    p: TClass1;
  end;

Delphi-Quellcode:

unit Unit1;

uses Unit3...

Delphi-Quellcode:

unit Unit2;

uses Unit3...

und fertig ;)

[stoxx]

Hi dizzy,

es bleibt dabei, dass ich halt in Unit3 alle Implementationen integrieren muss. Von beiden Objecten.
Und das is halt nich schön..

[dizzy]

Also ich halte das eigentlich für besonders schön, da man dadurch sehr nett modularisiert. Wenn du auf einmal einen der Typen in einer weiteren Unit brauchst, reicht es die deklarierende Unit einzubinden, und du kommst nie in die Verlegenheit von Kreuzbezügen. Ich habe mir mittlerweile angewöhnt jede Klasse in eine eigene Unit zu packen bzw. sehr eng verwandte. Das eigentliche Programm hingegen enthält nur die Klassendefinition "TForm1", alles weitere wird "ge-used".
Bin damit bisher sehr gut gefahren, und die Übersichtlichkeit gewinnt zudem :).

Gruss,
Fabian

[dartrax]

Zitat:

Zitat von dizzy

Genau das will er ja nicht machen.

Imho ist die einzige saubere Lösung der Umweg über eine 3. Unit die nur die Deklaraktionen enthält.

Zitat:

Zitat von stoxx

da geht natürlich nicht, da man dort ja wieder den überkreuzenden bezug von Unit1/Unit3 und umgekehrt hat.

Das stimmt nicht, da du aus Unit3 die anderen beiden ja garnicht zu referenzieren brauchst.

Aber dann stehen doch im Interface-Teil der Unit3 die gesamten Eigenschaften und Methoden der Klassen, im Implementation-Teil werden die Methoden jedoch nicht realisiert? Sondern im Implementation-Teil der Units jeweiligen Klassen? Dann kommt bei mir der "Ungenügende Forward- oder External-Deklaration: ..."-Fehler. Wenn ich im Implementationteil der Unit3 noch mal ein Uses auf die anderen Units setze, ist dieser Fehler behoben, aber die anderen Klassen kennen ihre (von Unit3 "entführte") Klassendeklaration nicht mehr! Obwohl ich im Interface-Teil auf die Unit3 verweise! (Ich weiß nicht, ob der Fehler daher rührt oder schon vorher existierte)

Vielleicht kann einer noch mal ein Beispiel posten. Ich habe zwei Klassen, in deren Interface-Teil muss jede auf die jeweils andere verweisen. Methoden gibt's natürlich auch. Die Implementation soll in eigenen Units erfolgen.

Benutze Delphi 7.

Vielen Dank,
dartrax

[rantanplan99]

Du könntest das mit einem Interface lösen. In einem Interface werden nur die Funktionen und Properties definiert. keine Implementierung davon. Deine Klassen TClass1 und TClass2 erweitern das Interface nur, bzw. müssen die im Interface deklarierten Funktionen implementieren. Schau die das mit den Interfaces in der Online-Hilfe an.

Grobes Gerüst:

Unit3:

Delphi-Quellcode:

IClass1 = interface
  Procedure Proc1(parameter...);
  Procedure Proc2(parameter..);
end;

IClass2 = Interface
  Procedure TueWas(parameter..);
  Procedure TueWasAnderes(..);
end;

In Unit1 dann:

Delphi-Quellcode:

uses Unit3;

TClass1 = class(TObject, IClass1)
  p2: IClass2;
  Procedure Proc1(parameter...);
  Procedure Proc2(parameter..);
end;

impelementation

Procedure TClass1.Proc1(paramemeter...);
begin

end;

...

In Unit2 dann analog zur Unit1:

Delphi-Quellcode:

uses Unit3;

TClass2 = class(TObject, IClass2)
  p2: IClass1;
  Procedure TueWas(parameter..);
  Procedure TueWasAnderes(..);
end;

impelementation

Procedure TClass2.TueWas(paramemeter..);
begin

end;

...

Ich denke so in etwa müsste das funktionieren, bin mir allerdings nicht ganz sicher. In Unit3 brauchst du keine implementierung zu den Funktionen schreiben. Habe das nicht ausprobiert. Schau halt in der Hilfe nach wie genau das geht.

rantanplan

[n0b0dy@home]

die antwort von rantanplan99 ist am sinnvollsten, da unit3 nur die interfaces bestimmt.

wenn du die beiden klassen benutzen moechtest, wuerde ich dir empfehlen, nur ueber die schnittstelle auf die objekte zuzugreifen. innerhalb der objekte geht ja ohnehin nichts mehr anderes.

warum muss eigentlich ein kreuzbezug zwischen den beiden klassen bestehen?

[BenBE]

Einfachste und sauberste Lösung:

Forward-Deklaration von TClass2
Deklaration von TClass1
Deklaration von TClass2

Alles in eine Unit packen.

Anders geht's nicht!

[n0b0dy@home]

naja, das ganze laesst aber auf einen design-fehler schliessen, wenn ich einen kreuzbezug erzeuge. es wuerde mich schon interessieren, warum er hier von noeten ist.

[BenBE]

Dann wär die VCL ein einziger Designfehler: Dort wird in TControl bereits auf TWinControl verwiesen, und ähnliches.

Forward-Deklarationen sind von daher gesehen in vielen Situationen sogar seh nützlich.

@Möglicher Designfehler: Probleme bei der Hierarchie der Komponentenvererbungen, d.h. keine eindeutigen Vererbungen und Datenflüsse.

[n0b0dy@home]

innerhalb einer unit ist es in ordnung. dass war ja auch dein loesungsvorschlag. er hat aber einen kreuzbezug zweier units. das wuerde mich interessieren.