Problem mit automatischem freigeben von Interfaces

[Memnarch]

Moin,
Habe nen problem:

Wenn ich eine Klasse TFoo haben, die IFoo implementiert und jetzt folgendes mache:

Delphi-Quellcode:

procedure TOtherClass.Test(AFoo: IFoo);
begin
  AFoo.DoSomething();
end;

procedure TTestClass.Action();
var
  LFoo: TFoo;
  LOtherClass: TOtherClass;
begin
  LFoo := TFoo.Create();
  LOtherClass := TOtherClass.Create();
  LOtherClass.Test(LFoo);
  LFoo.dosomethingmore();<-- hier ists bereits freigegeben
end;

Knallst wegen dem reference counting. Wie mach ich es jetzt am besten, das ich ein Object and eine methode übergebe, die ein Interface erwartet?
Ich brauche das object danach noch

Muss ich mir das Interface seperat rausholen und das übergeben?(womit ich die interface variable bis zum ende behalten kann)

MFG
Memnarch

[Sir Rufo]

Kurz und knapp: ja, aber du musst, kein kann

EDIT: Allerdings hängt es auch davon ab, wovon deine Klasse abgeleitet wurde. Von TComponent, dann passiert das nicht

[Memnarch]

Zitat von Sir Rufo:

EDIT: Allerdings hängt es auch davon ab, wovon deine Klasse abgeleitet wurde. Von TComponent, dann passiert das nicht

Welche muss von TComponent abgeleitet werden? Das object dass das Interface implementiert oder dass das die methode die das interface erwartet implementiert?
Und wieso passiert das da nicht?!

edit: ah ok, sehe TComponent implementiert interfaces, meine letzte Frage bleibt aber bestehen, und für nicht visuelle objecte die nur etwas bearbeiten scheints mir fehl am platz von TComponent abzuleiten. Momentan wird von TInterfacedObject abgeleitet.

[jaenicke]

Weil TComponent die Referenzzählung deaktiviert, aber das möchtest du ja gar nicht.

An der Stelle ist es ganz einfach: Mit dem Objekt darf man nur arbeiten bis es das erste Mal als Interface benutzt wird. (Oder lokal eine Interfacevariable halten.)

[Memnarch]

@Jaenick: oh das abschalten der Zählung macht nichts. Den automatismuss brauch ich gar nicht, da die objekte bisher eh normal verwaltet wurden, und es auch weiterhin werden sollen(heute erst den Interface kram implementiert weil ich ne klassenübergreifende schnittstelle brauchte)

EDIT: so jetzt gibts TUncountedInterfacedObject, und die Welt ist wieder heile

[sx2008]

Es gibt 2 sinnvolle Praktiken.
In die Referenzzählung würde ich nicht eingreifen, denn für denjenigen, der den Code liest, wäre das überraschend.
a) nur mit dem Interface arbeiten

Delphi-Quellcode:

procedure TOtherClass.Test(AFoo: IFoo);
begin
  AFoo.DoSomething();
end;

procedure TTestClass.Action();
var
  Foo: IFoo;  // nicht das Objekt, sondern den Interfacezeiger speichern
  LOtherClass: TOtherClass;
begin
  Foo := TFoo.Create();
  LOtherClass := TOtherClass.Create();
  LOtherClass.Test(Foo);
  Foo.dosomethingmore();  // dosomethingmore() muss natürlich im Interface deklariert sein
end;

b.) wie a.) nur darf zusätzlich noch auf das Objekt zugegriffen werden

Delphi-Quellcode:

procedure TOtherClass.Test(AFoo: IFoo);
begin
  AFoo.DoSomething();
end;

procedure TTestClass.Action();
var
  Foo: IFoo;      // 
  FooObj : TFoo;  //
  LOtherClass: TOtherClass;
begin
  FooObj := TFoo.Create();
  Foo := FooObj; // Achtung: FooObj darf nicht mit Free freigegeben werden
  LOtherClass := TOtherClass.Create();
  LOtherClass.Test(Foo);
  FooObj.dosomethingmore();
  ...
  FooObj := nil; // Zeile dient nur dazu uns daran zu erinnern, dass FooObj nicht mit Free freigegeben werden darf
end;

[Bummi]

TInterfacePersistant ?

[Memnarch]

@Bummi: Oh, hatte gar nicht gesehen das TInterfacedPersistent den Refcounter u.U. auch abschaltet o.O

[Elvis]

Wenn eine Interface-Referenz per const übergeben wird, wird keine autom. Referenzzählung gemacht.

Delphi-Quellcode:

procedure TOtherClass.Test(const AFoo: IFoo);
begin
  AFoo.DoSomething();
end;

Natürlich kann die Implementierung von DoSomething wiederum zu Referenzzählungsproblemen führen.
Aber nicht weil es auf eien Interface-Referenz ausgeführt wird, sondern weil dort vllt AFoo als Interface irgendwo reingestopft wird...

[himitsu]

Zitat von Elvis:

Wenn eine Interface-Referenz per const übergeben wird, wird keine autom. Referenzzählung gemacht.

Aber auch nur, wenn es da schon eine Interface-Referenz ist.

Übergibt man eine objektinstans ala TFoo, dann wird diese schon vor dem Methodenaufruf in ein Interface "konvertiert" und dabei wird natürlich kurzzeitig die Referenzzählung beeinflußt.