Problem beim zugreifen von Unit auf Form

[1ceman]

Ich habe eine Unit U_List, woRichedits verwaltet werden, die ich während der Laufzeit erzeuge.
Diese Unit hab Ich bei der Unit1 von der Form bei uses hinzugefügt.
Wie kann ich jetzt von der Unit U_List aus auf Objekte, die auf der Form sind zugreifen?
Ich hab schon versucht bei U_list bei Uses die Unit1 anzugeben, doch dann kommt der Fehler:
Circular unit reference to Unit1 Was ja auch irgendwie logisch ist.

[konda]

kannst du nicht die verwaltung der richedits nach unit1 verlagern? Das würde das Problem lösen.

Ich hatte das Problem auch mal und hab es so gelöst.

[NormanNG]

Hi,

einfach die Referenz auf Unit u_list nach [implementation] einfügen.

[1ceman]

hab jetzt die erste variante genommen, also alles in die eine Unit gepackt, so geht alles.
Danke für eure Hilfe

[Der_Unwissende]

HI,
an sich gibt es für dein Problem mind. zwei Lösungsmöglichkeiten.
Dabei möchte ich hier erwähnen, dass nur eine davon wirklich verwendet werden sollte. Die andere möchte ich nur nennen, da du sie finden kannst (auch in der DP). Deshalb fange ich mit dieser an und möchte auch gleich begründen warum du sie nicht verwenden solltest.
Unter Delphi gibt es die Möglichkeit über Kreuz/zyklisch einzubinden. Dazu kannst du die Uses Klauseln einmal im Interface und einmal im Implementation Teil eintragen. Damit bleibt aber das eigentliche Problem erhalten. Du schaffst hier eine Abhängigkeit, die völlig unnötig ist. Die beiden Klassen kannst du so nicht mehr einzeln verwenden und das gilt immer als schlechtes Design von Software.

An sich hast du schon einen guten Ansatz. Du sprichst von einer Klasse, die RichEdits verwaltet. Das ist gut, wenn hier nichts anderes stattfindet. Die Anzeige der TRichEdits wäre schon eine Sache, die man von der Verwaltung trennen kann (siehe Mehrschicht-Modelle oder MVC).
Jedenfalls ist hier eine der deutlich besseren Möglichkeiten, dass du eine Klasse schaffst, die sowohl das Formular als auch die Verwaltung der RTFs kennt (also die beiden Units in die eigene Uses Klausel aufnimmt) und zwischen beiden vermittelt. Dies wäre eine Möglichkeit, aber noch immer nicht die Beste.
Wie die Beste aussieht kann pauschal eh nicht gesagt werden, da kommt es immer darauf an, was du eigentlich machen willst (was aus deinem Beitrag nicht genug hervor geht).
Die Frage ist, was muss die Verwaltung eines TRichEdits wissen? Sie sollte eigentlich komplett ohne ein spezielles Formular auskommen. Alles was du von dem Formular wissen möchtest, kennt eigentlich schon die Unit des Formulars (logischer Weise). Was du hier letztlich benötigst sollten sehr primitive Datentypen (Texte/Strings, Zahlen, ...) sein. Diese kannst du als solchen Typen von dem Formular an eine Unit übergeben, ohne dass diese andere Unit wissen müsste wo die Daten herkommen. Möchtest du z.B. auf die Eingabe in einem TEdit reagieren wollen, könnte dein Formular den String dieses TEdit einfach weiterreichen.
Letztlich geht es bei Design deiner Software immer darum, dass jede Unit möglichst wenig von ihrer Umwelt wissen sollte. Damit kannst du die einfach wiederverwenden. Zu dem erhöht es die Möglichkeit, einzelne Teile auszutauschen, da es hier wenig oder keine Abhängigkeiten gibt.

Hier ist es schwer ein konkretes Beispiel zu deinem Problem zu nennen, da ich nicht weiß was deine Verwaltung im Moment vom Formular wissen soll.

Gruß Der Unwissende

[ADD nach rotem Kasten]
Oh, das ist übrigens eine gaaaanz schlechte Lösung!
Units sollten immer nur ein Problem behandeln. Alles andere macht sie unnötig groß (und damit nicht zu letzt auch deine Programme). Große Dateien kann man deutlich schlechter lesen und damit auch schlechter warten. Die Abhängigkeiten sind auch entsprechend groß, du kannst hier ja nichts austauschen. Es ist eine wirklich schlechte Lösung und sollte nie als Alternative in Betracht gezogen werden
[/ADD]

[1ceman]

Hier eine Übersicht über die proceduren und funktionen der Unit U_List

Delphi-Quellcode:

type
    TElement = class                        { Urobjekt für Listenelemente      }
       Next: TElement;                      { Nachfolger                       }
       R : TJvRichEdit;
       B : TJvTransparentButton;
       Name : String;
       Constructor Create(N : String; Owner, Owner2 : TComponent; Anzahl : Integer);   { Konstruktor wird verändert       }
       Procedure UserButton(Sender: TObject);
     end;

     TLinList = class                           { Liste über Urtyp TElement    }
       private

       public
       sAnfang, sAktuell: TElement;             { "Zeiger" auf erstes/         }
                                                { aktuelles Element            }
         constructor create;                    { setzt Kopf/Fuss auf NIL      }
         destructor destroy; override;          { löscht alle vorh. Elemente   }
       { Navigationsroutinen }
         procedure vor;                         { Aktuell einen weiter bewegen }
         procedure zurueck;                     { Aktuell einen zurück bewegen }
         procedure zumAnfang;                   { Aktuell an den Anfang        }
         procedure zumEnde;                     { Aktuell an das Ende          }
       { Datensatzoperationen }
         procedure EinfuegenVor(e: TElement);   { Datensatz vor Aktuell einf.  }
         procedure EinfuegenNach(e: TElement);  { Datensatz nach Aktuell einf. }
         procedure Loeschen;                    { Aktuellen Datensatz loeschen }
       { Informationsroutinen }
         function Anzahl: integer;              { Anzahl der Datensätze        }
         function amEnde: boolean;              { Aktuell am Ende?             }
         function amAnfang: boolean;            { Aktuell am Anfang?           }
         function Leer: boolean;                { Anzahl = 0?                  }
         function Aktuell: TElement;            { Aktuelles Element ausgeben   }
         function Index: integer;               { Nr. des Aktuellen Elements   }
     end;

Also wie schon gesagt verwaltet diese Unit Richedits und Buttons, die während der Laufzeit erstellt werden.
Diese Richedits liegen auf einem TabControl. Wenn man jetzt einen der erzeugten Button drückt, soll dem TabControl ein Tab hinzugefügt
werden und das entsprechende Richedit angezeigt werden. Das Problem ist jetzt nur, dass ich mit der Buttonprocedure auf das TabControl auf
der Form zugreifen muss, was halt nicht geht.
Ich hoffe das ich mein Problem genau genug beschrieben habe, damit ihr mir sagen könnt, wie ich es am besten löse.

[Der_Unwissende]

Zitat von 1ceman:

Also wie schon gesagt verwaltet diese Unit Richedits und Buttons, die während der Laufzeit erstellt werden.
Diese Richedits liegen auf einem TabControl. Wenn man jetzt einen der erzeugten Button drückt, soll dem TabControl ein Tab hinzugefügt
werden und das entsprechende Richedit angezeigt werden. Das Problem ist jetzt nur, dass ich mit der Buttonprocedure auf das TabControl auf
der Form zugreifen muss, was halt nicht geht.
Ich hoffe das ich mein Problem genau genug beschrieben habe, damit ihr mir sagen könnt, wie ich es am besten löse.

Ja, das ist schon viel besser erklärt.
Du sagst aber vollkommen richtig:

Zitat von 1ceman:

Diese Richedits liegen auf einem TabControl

Wie gesagt, das ist so vollkommen richtig. Sie liegen später auf einem Tabcontrol, du musst aber für ihre Verwaltung doch gar nicht wissen auf welchem, oder? Du hast also die Möglichkeit (z.B.) beim anlegen deiner Klasse ein TabControl zu übergeben.
Du könntest also praktisch etwas in der Richtung erstellen:

Delphi-Quellcode:

TLinList = class(TObject) 
  private
  FTabControl : TTabControl;
  ...
  public
    constructor create(TabControl : TTabControl);
    ...
end;

Dann hättest du die Möglichkeit, dass dein Formular zwar die Unit U_List kennen müsste, aber nicht umgekehrt. Die U_List bekommt dann im Konstruktor ein TTabControl übergeben. Es muss nicht wissen wo dieses herkommt! So hast du alle Eigenschaften eines TTabControls ohne dass du die Unit kennst aus der dieses kommt. Erstellst du jetzt also ein zweites Formular in einer weiteren Unit, so könntest du auch diesem die Funktionalität von U_List zur Verfügung stellen (um nochmal die Wiederverwendbarkeit zu verdeutlichen).

Die Frage ist halt welche Eigenschaften von einem TTabControl du wirklich benötigst.
Du kannst halt die Vorteile der Objekt Orientierung (OO) immer ganz gut nutzen. Hier siehst du ja schon, dass du nun ein beliebiges TTabControl übergeben könntest. Dabei ist es egal, woher es kommt und die Unit funktioniert mit jedem TTabControl. Allerdings gibt es Komponenten, die du sicherlich noch viel allgemeiner verwenden möchtest. Typische Beispiele wären hier alle VCL-Komponenten. Du möchtest ein Label sicherlich sowohl auf einem beliebigen Formular, einem Frame, einem Panel, ... (insbesondere auch eigenen Komponenten) verwenden können. Hier kannst du dann die Vererbung ausnutzen.
Klassen können von anderen Klassen erben. Statt vom Vererben kann man auch vom Erweitern sprechen (in Java wird z.B. das Schlüsselwort extends verwendet). Jedenfalls hat jeder Erbe alle Eigenschaften seines Vorgängers (genauer aller Vorgänger).
Die Vererbungshierachie findest du in der Delphi Hilfe unter Hierachie.
So erbt z.B. jede Klasse aut. von TObject. Alle Eigenschaften und Methoden von TObject stehen damit jeder Klasse zur Verfügung. Das siehst du z.B. immer dann, wenn du im Konstruktor inherited create aufrufst. Damit musst du dich einfach nicht selbst um das Erzeugen einer neuen Instanz kümmern.

In deinem Fall solltest du schauen, welche Eigenschaften du wirklich benötigst. Würdest du z.B. im Konstruktor statt einem TTabControl dann ein TCustomTabControl verwenden, hast du hier wieder eine Menge mehr Möglichkeiten. TTabControl ist eine sehr konkrete Klasse, alle anderen kannst du hier nicht übergeben. TCustomTabControl hingegen ist eine (abstrakte) Basisklasse. Verwendest du diese, kannst du alle Nachfahren übergeben (und hast alle Eigenschaften zur Verfügung). Damit könntest du dann alle TTabControls übergeben, aber z.B. auch alle TPageControls (falls du hier mal was ändern möchtest) oder alle anderen Nachfahren (z.B. die TabControls aus den Jedis).

Ich hoffe, das der Vorteil grob klar ist. Im Moment bindest du dich halt ein spezielles Formular. Das ist nie gut! Alle großen Systeme arbeiten in getrennten Schichten, aber auch sehr viele kleinere tun dies. Und das nicht ohne Grund. Schon das sehr einfache MVC Konzept bringt dir eine Menge Vorteile. Deswegen kann ich dir nur empfehlen es dir anzuschauen!
Auch wenn es nicht überall nötig scheint, Projekte wachsen schneller als man glaubt und einen Nachteil hat diese Trennung nie. Solltest du z.B. ein zweites Formular nehmen und hier die gleiche Verwaltung von Buttons und TabControls verwenden wollen, kannst du diese Verwaltung natürlich auch in die zweite Unit kopieren. Dann merkst du irgendwann, dass dir ein Fehler unterlaufen ist. Möchtest du den korrigieren, darfst du also in allen Units die diese Verwaltung verwenden gehen und es hier anpassen (überleg dir einfach mal, was ist wenn es mehr als 2 sind). Noch ein wenig später, merkst du dass du das alles viel effizienter machen könntest...

Wie gesagt, in jede Unit sollte immer nur die Lösung eines Problems / einer Gruppe von Problemen rein. Eine Klasse pro Unit finde ich persönlich auch vollkommen ok. Das ist dann aber eher Geschmackssache. Nur je kleiner eine Datei ist, desto leichter blickst du in dieser Unit durch, desto klarer ist was in dieser Unit passiert, desto weniger Abhängigkeiten ermöglichst du, usw.

[1ceman]

Delphi-Quellcode:

type
     TElement = class                        { Urobjekt für Listenelemente      }
       Next: TElement;                       { Nachfolger                       }
       Constructor Create();                 { Setzt Next auf Nil               }
     end;

     TChat = class(TElement)
       R : TJvRichEdit;
       B : TJvTransparentButton;
       Name : String;
       Constructor Create(N : String; Owner, Owner2 : TComponent; Anzahl : Integer);   { Konstruktor wird verändert       }
       Procedure UserButton(Sender: TObject);
     end;

     TLinList = class(TObject)                  { Liste über Urtyp TElement    }
       private
        Tabc : TJvgTabControl;
       public
       sAnfang, sAktuell: TElement;             { "Zeiger" auf erstes/         }
                                                { aktuelles Element            }
         constructor create;                    { setzt Kopf/Fuss auf NIL      }
         destructor destroy; override;          { löscht alle vorh. Elemente   }
       { Navigationsroutinen }
         procedure vor;                         { Aktuell einen weiter bewegen }
         procedure zurueck;                     { Aktuell einen zurück bewegen }
         procedure zumAnfang;                   { Aktuell an den Anfang        }
         procedure zumEnde;                     { Aktuell an das Ende          }
       { Datensatzoperationen }
         procedure EinfuegenVor(e: TElement);   { Datensatz vor Aktuell einf.  }
         procedure EinfuegenNach(e: TElement);  { Datensatz nach Aktuell einf. }
         procedure Loeschen;                    { Aktuellen Datensatz loeschen }
       { Informationsroutinen }
         function Anzahl: integer;              { Anzahl der Datensätze        }
         function amEnde: boolean;              { Aktuell am Ende?             }
         function amAnfang: boolean;            { Aktuell am Anfang?           }
         function Leer: boolean;                { Anzahl = 0?                  }
         function Aktuell: TElement;            { Aktuelles Element ausgeben   }
         function Index: integer;               { Nr. des Aktuellen Elements   }
     End;

Ich hab TElement verändert, TChat hinzugefügt und bei TLinList unter private das "Tabc : TJvgTabControl;" eingefügt.
Nur das Problem ist, dass die Liste Die Elemente vom Typ TElement verwaltet und TElement den Typ TLinList nicht kennt und folglich nicht von der Procedure UserButton auf TabC zugreifen kann. Wenn ich "Tabc : TJvgTabControl;" jetzt bei TChat einfüge, dann hat jedes Element ein eigenes TabControl und nicht alle zusammen eins. Kann ich dem Typ TChat nicht einfach einen Zeiger auf das tabControl mitgeben, damit ich von dort aus
ein Tab hinzufügen kann?

[Der_Unwissende]

Zitat von 1ceman:

Nur das Problem ist, dass die Liste Die Elemente vom Typ TElement verwaltet und TElement den Typ TLinList nicht kennt und folglich nicht von der Procedure UserButton auf TabC zugreifen kann. Wenn ich "Tabc : TJvgTabControl;" jetzt bei TChat einfüge, dann hat jedes Element ein eigenes TabControl und nicht alle zusammen eins. Kann ich dem Typ TChat nicht einfach einen Zeiger auf das tabControl mitgeben, damit ich von dort aus
ein Tab hinzufügen kann?

Natürlich kannst du das machen, die Frage ist halt, musst du es tun. Es gibt immer irgendwo Punkte, wo sich eine Abhängigkeit nicht vermeiden lässt, dass ist so schon ok, die Kunst liegt darin die Abhängigkeiten so klein wie möglich zu halten.
Deine Liste z.B. ist hier z.B. eine (sorry) schlechte Lösung. Du kannst auch auf die TObjectList zurückgreifen. Dies ist eine Art von Liste, die mittels Arrays verwaltet wird. Die Implementierungsdetails sind aber (dank Kapselung) völlig egal. Du hast eine fertige Liste, die sogar wahlfreien Zugriff auf die Elemente (über den Index) erlaubt und doppelt-verkettet ist.

Was dein Problem angeht, ist halt die Frage, was genau UserButton machen soll. Ich meine klar, ich kann jetzt raten, aber weit würde ich wohl nicht kommen. Deshalb hier nochmal der Hinweis, der allg. für alle Beiträge gilt:
Je genauer und einfacher du dein Problem beschreibst, desto leichter kann dir jmd. helfen. Deshalb schreib lieber ein wenig mehr zum Problem. Das hilft allen. Wenn du dein Problem aufschreiben möchtest/musst, dann musst du dir vorher auch klar sein, worin es liegt (sonst klappt das mit dem Formulieren nicht), hierbei kommen einem häufig noch Ideen, so dass man selbst seine Fehler bemerkt bzw. eine Lösung findet. Andererseits hilft es den Leuten, die dir helfen wollen. Die können dir dann sehr genau sagen, wie geeignet dein Ansatz ist, dir evtl. Alternativen zeigen und vorallem dir direkt zum richtigen Problem helfen. Hier kommt es immerwieder vor, dass jmd. der denkt eine Beschreibung verstanden zu haben ein ganz anderes Problem löst.

Also sei doch so gut und erläuter erstmal in groben Zügen, was dein Programm so leisten soll. Wenn du dies getan hast (es muss ja nicht lang sein, versuche es aber auch verständlich zu halten, keiner ausser dir weiß was du vor hast), dann geh einfach auf dein konkretes Problem ein. Ich sehe, du möchtest hier auf ein Element zugreifen, mir ist nur leider überhaupt nicht klar warum? Was möchtest du mit dem Element machen? Was macht UserButton überhaupt? Und da es verdächtig nach einem Ereignis aussieht (bzw. dessen Behandlung), wann wird es ausgelöst?! Dir wird das alles sicherlich klar sein und da ist es auch verständlich, dass man mal übersieht, dass man ein paar Details zu vergisst / vorraussetzt (ubewußt), nur kann man dir so echt schwer helfen.

[1ceman]

Ich hab vor meinen Chat ein bissl zu verändern.
Rechts hat jeder Client eine Anzeige mit allen Usern die im Chat sind, wobei jeder User nen eigenen Button/Label bekommen soll.
In der Mitte gibt es ein TabControl. In diesem TabControl sollen neue Tabs und Richedits erstellt werden, wenn man auf einen User klickt, es sei denn es wurde schon ein Tab für ihn erzeugt. Zusätzlich gibt es noch ein Tab und ein Richedit in dem man mit allen chatten kann und was immer vorhanden ist(und bei schon beim start erzeugt wird).

Ich hoffe ihr versteht was ich vorhabe und könnt mir helfen.