Mein aktueller Meinungsstand:
Künftige Verwendung von Interfaces: UNBEDINGT!
Ebenso das Verbergen der Klassen-Units untereinander (im Regelfall).
Im Projekt sollen dann grundsätzlich nur die Schnittstellen bekannt sein.
Auf eine Verschachtelung von Objekten über deren Owner werde ich verzichten. Beziehungen untereinander werden über eine Property abgebildet, die die ID des referenzierten Objektes enthält.
Auf Spring werde ich (vorerst) verzichten und mir selbst eine "Factory" (oder wie müsste man das nennen?) bauen, die auf Anfrage Objekte erzeugt und deren Schnittstellen zurück liefert. Wird keine ID bei der Anforderung angegeben, wird eine neue erzeugt. Die ID besteht aus zwei Zeitstempeln und einem Zufallswert (Programmstartzeit und Now und Random) und dürfte damit weltweit nicht doppelt vorkommen und eindeutig nach der Erstellungsreihenfolge sortierbar sein (im Gegensatz zu einer
GUID).
ID + Interface werden in einem Dictionary gespeichert (dadurch erhöht sich m.E. der RefCount).
Wird ein Interface eine gewisse Zeit nicht mehr abgerufen und der RefCount ist 1 wird es aus dem Dictionary entfernt (und das Objekt somit aufgelöst).
Ich könnte also sagen: IMyPerson := Factory.GetPerson(PersonId, InClubId);
Die Factory kümmert sich dann darum, die Objekte herauszusuchen bzw. ggf. zu erzeugen und ggf. die Verbindung zu anderen Objekten einzurichten und die Schnittstellen heraus zu geben.
Ich denke, das würde ich lieber selbst an zentraler Stelle regeln, anstatt Spring einzusetzen, von dem ich wenig verstehe.
Diesen Weg würde ich mir wünschen - wenn es so realisierbar ist. Ich könnte mir vorstellen, dass man damit sehr übersichtlich abeiten kann.
Weitere Überlegungen: (Ich bleibe mal hier im Thread, da das thematisch schon noch zusammen gehört.)
Die Daten jedes Objektes würden in einer einfachen
DB gespeichert. Je Klasse eine Tabelle, je (mit Attribut gekennzeichneten) Property ein entsprechendes Feld. Die Tabellen können jederzeit anhand der Klassendefinition passend erzeugt werden.
Im Grunde wäre das ja schon ein kleiner ORM.
Oder sollte man dann doch lieber gleich zu mORMot oder DORM greifen und nicht alles neu erfinden? Aber die arbeiten wieder nicht mit Interfaces? Fragen über Fragen...
Letztlich geht es dann natürlich auch noch um die Datenbindung an die
GUI. Bei meinem odControls habe ich alles fest verdrahtet. Jeder Tastendruck z.B. in einem odEdit hat sofort den Inhalt eines Propertys verändert. Es gibt also keine Transaktionen oder Prüfungen, die die Übergabe von Änderungen aus der
GUI in die Datenebene kontrollieren.
Diesbezüglich muss ich mich dann doch mal genauer mit DSharp und LiveBinding auseinandersetzen.
Ich weiß, dass ich ohne ein Databinding nicht mehr arbeiten will. Wie genau, ist aber noch nicht entschieden.
Nachtrag: Die
GUI-Controls müssten eigentlich eine ID und PropertyName zugewiesen bekommen und sich darauf hin aus der Factory das entsprechende Objekt abrufen und sich an dieses binden. An der Stelle wird man mit Interfaces sicher nicht weiter kommmen - oder? Oder kann die
RTTI mit Interfaces genau wie mit Objekten umgehen?
Und wann sollen die
GUI-Controls der Factory bescheid geben, dass die bereit gestellten Objekte/Interfaces wieder freigegeben werden können?
Oh Mann - sooo viele Fragen.