Umgang mit Interfaces

[TiGü]

Zitat von OlafSt:

Sehe ich das richtig, das mein MySomeThingObject bei Verlassen der Prozedur automatisch freigegeben wird, obwohl ich zuvor mit TMyDoSomething.Create; Speicher dafür alloziert habe ?

Wie oben erwähnt, ja!

Mit einem normalen Objekt hättest du ein Speicherleck!

[OlafSt]

Zitat von TiGü:

Zitat von OlafSt:

Sehe ich das richtig, das mein MySomeThingObject bei Verlassen der Prozedur automatisch freigegeben wird, obwohl ich zuvor mit TMyDoSomething.Create; Speicher dafür alloziert habe ?

Wie oben erwähnt, ja!

Mit einem normalen Objekt hättest du ein Speicherleck!

Das ist mir klar, ich programmier schon ein paar Tage länger mit Delphi Ich hätte nicht gedacht, das meine simple Frage eine derartige Diskussion auslöst, die für mich aber ungeheuer interessant war. Bleibt noch eine letzte Frage übrig. Wenn ich so ein selbsterzeugtes MySomeThingObject nun in eine TList (nicht in der Prozedur deklariert) stecke, dann:

A) bleibt mein MySomeThingObject trotz verlassen der Prozedur existent
B) mit dem Freigeben meiner TList werden auch alle dort drin befindlichen MySomeThingObjects elimiert ?

Wenn hier 2x JA kommt, haben wir ja schon fast C#-Verhältnisse...

[himitsu]

bei Objekten:
Nein
und
Nein

Objekte mit TObjectList:
Nein
Ja

Interface mit Interfaces ode TObjectlist:
Ja
Ja

[Whookie]

Aber einsetzbar sind Interfaces anscheinend nur für simple Dinge, sobald Beziehung zwischen den Instanzen abgebildet werden müssen, verhindert die Referenzzähling eine Verwendung (siehe Beispiel aus meinem letzen Beitrag, dort werden Destructoren nicht aufgerufen, weil die Referenzzählung es beim Freigeben verhindert).

Ich habe das selbe Beispiel nochmals mit Interfaces ohne Referenzzählung implementiert, dann funktiniert die Referenzierung zwar, aber beim Freigeben kommet es dann zu Zugriffsfehlern weil Delphi anscheinend _Release auch dann noch aufruft, wenn das dazugehörige Objekt nicht mehr existiert.

Bleibt als die Schlußfolgerung, das Interfaces nicht geeignet sind komplexere Zusammenhänge abzubilden?!??

Für meinen speziellen Fall wäre es also eine Option eine Basisklasse zu deklarieren, die alle Eigenschaften aller Interfaces beinhaltet und in den jeweilig abgeleiteten Kindern die benötigte Funktion entsprechend zu implementieren. Dann lassen sich die Referenzen untereinander verlinken, aber schön ist das halt nicht!

[himitsu]

Man muß dann nur die Referenzzählung richtig implementieren.

z.B.
- von den Unterkomponenten die Referenzzählung auf den obersten Knoten weiterleiten (bzs, an den Besitzer)
- Rückwärtsreferenzen aus der Referenzzählung ausnehmen

[Whookie]

Zitat von himitsu:

- von den Unterkomponenten die Referenzzählung auf den obersten Knoten weiterleiten (bzs, an den Besitzer)
- Rückwärtsreferenzen aus der Referenzzählung ausnehmen

..wenn ich mir das so recht überlege muss die Not schon groß sein, so etwas anzugehen (schon gar bei den nur rudimentär vorhandenen Debugmöglichkeiten von XE4 )...

[jaenicke]

Ich habe das bei mir so, dass sich die GUI-Interfaces gegenseitig mit den dahinterliegenden Interfaces einklinken. Wenn man das sauber umsetzt und klar ist wer sich wann und wie wieder deregistriert, hatte ich damit noch nicht die kleinsten Probleme.

Und der Debugger funktioniert bei mir problemlos, außer wenn wieder jemand with benutzt hat. (Das geht dann eh gleich an den Pranger...)

[Patito]

Zitat von Whookie:

Aber einsetzbar sind Interfaces anscheinend nur für simple Dinge, sobald Beziehung zwischen den Instanzen abgebildet werden müssen, verhindert die Referenzzähling eine Verwendung (siehe Beispiel aus meinem letzen Beitrag, dort werden Destructoren nicht aufgerufen, weil die Referenzzählung es beim Freigeben verhindert).

Bleibt als die Schlußfolgerung, das Interfaces nicht geeignet sind komplexere Zusammenhänge abzubilden?!??

Richtig erkannt. Man stößt bei dem Thema etwas an die Grenzen von Delphi. Als Interfaces in Delphi eingeführt wurden, ist denen leider gerade der Chef-Entwickler abhanden gekommen...
Systeme mit automatischer Referenzzählung kennen normalerweise so etwas wie Weak-References. Die gibt es bei Delphi-Interfaces so nicht. Alles ist eine Strong-Referenz, und mit einer solchen Einschränkung zu programmieren ist ein ziemlicher Krampf. (Grüße an die ARC-Fans, die das noch nicht ganz mitbekommen haben...)

In Delphi kann man die Probleme zwar umgehen, aber es ist nicht ganz einfach. Ich habe vor ein paar Jahren mal versucht einer Moderatorin vom Borland-Forum zu erklären wie sie ihre Interface-Probleme umgehen kann, aber letztenendes hat sie ihre Delphi-Frameworks dann aufgegeben und sich einer anderen Programmiersprache zugewendet.

Etwas, das man häufig brauchen kann, ist z.B. ein Benachrichtigungs-Mechanismus, mit dem man einem Objekt, das eine Interface-Referenz hält mitteilen kann, dass es seine Referenz jetzt löschen muss (geht per Observer-Pattern). Hat man dann die Referenzen, die man selbst im Code verteilt hat erst einmal im Griff, muss man auch noch auf die Referenzen aufpassen, die der Compiler für Zwischenergebnisse (Funktions-Rückgabewert, ...) irgendwo auf den Stack gepackt hat. Macht alles keinen Spass.

Zur Lösung des Problems, wie gesagt: Ich habs für mich in Delphi gelöst, andere haben einfach aufgegeben. Die lautstärkste Delphi-Fraktion behauptet steif und fest, dass man Weak-References sowieso niemals braucht. An Deiner Stelle würde ich in Delphi die Verwendung von Interfaces zurückfahren oder auf Free Pascal umsteigen. Dort gibt es diese ganzen künstlichen Probleme nicht...

[himitsu]

Zitat von Patito:

Systeme mit automatischer Referenzzählung kennen normalerweise so etwas wie Weak-References. Die gibt es bei Delphi-Interfaces so nicht.

Das liegt nicht daran, daß es vergessen wurde.

In Delphi gibt es keine Stelle wo die Position aller Variablen registriert sind.
Auch gibt es keine Möglichkeiten nach Variablen zu suchen.

Systeme wie .Net oder JavaScript verwalten den Speicher anders, haben da praktisch eine Liste aller Variablen und können, wenn ein Interface freigegeben wird, einfach die restlichen Variablen suchen und diese auf Nil setzen.

In Delphi geht das nur, wenn man sowas auch für Variablen einbaut, also wo sich Variablen an einer globalen Stelle oder direkt beim Interface registrieren.
(das wollte ich mal vor Jahren nachrüsten, aber den nötigen Änderungswunsch hat man bisher seit knapp 6 Jahren igoriert, bzw. seit fast 4 Jahren den etwas neueren QC-Report).
http://qc.embarcadero.com/wc/qcmain.aspx?d=82524



Also seit 3 Jahren hätten wie Weak-Referenzen haben können, aber wer nicht will, der will halt nicht.
Selbst wenn man das jetzt nicht direkt als Klassen-Operatoren einbaut, sondern erstmal die nur 3 Grundevents implementiert hätte,
was mit knapp 10 Zeilen Quellcode erledigt gewesen wäre, wäre das Problem schon länger lösbar. (auch wenn nicht ganz so schön)