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:

Zitat von Sir Rufo (Beitrag 1187741)

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 :P

[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:

Zitat von Elvis (Beitrag 1187909)

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.

[Elvis]

Zitat:

Zitat von himitsu (Beitrag 1187912)

Zitat:

Zitat von Elvis (Beitrag 1187909)

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.

Nope, wie kommst du da drauf? :gruebel:
"Const" ist eines der wenigen Mittel, mit den man in Delphi überhaupt mit Interfaces arbeiten konnte, wenn man nicht komplett RefCounting genutzt hatte.

[himitsu]

Aber nur doch wenn man schon eine Interface-Referenz hat, welche man da übergeben kann.
Wenn erst soeine Instanz erstellt werden muß, dann sollte diese auch mit gezählt werden, da sie vor der Übergabe lokl in einer temporären Variable zwischengespeichert wird. :gruebel:


[edit]
Das überrascht mich jetzt aber, da ist wirklich kein AddRef :shock:

Delphi-Quellcode:

type
  ITest = interface
    ['{CB192645-8A70-4AB5-8EDD-ADD0304EDC27}']
  end;

  TTest = class(TObject, ITest)
    FRefCount: Integer;
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
    class procedure Test1(const Intf: ITest);
    class procedure Test2(Intf: ITest);
  end;

function TTest.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  ShowMessage('QueryInterface' + GUIDToString(IID));
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TTest._AddRef: Integer;
begin
  Inc(FRefCount);
  ShowMessage('_AddRef ' + IntToStr(FRefCount));
end;

function TTest._Release: Integer;
begin
  Dec(FRefCount);
  ShowMessage('_Release ' + IntToStr(FRefCount));
end;

class procedure TTest.Test1(const Intf: ITest);
begin
  if Assigned(Intf) then ;
  ShowMessage('call Test1');
end;

class procedure TTest.Test2(Intf: ITest);
begin
  if Assigned(Intf) then ;
  ShowMessage('call Test2');
end;

procedure TForm11.Button2Click(Sender: TObject);
var
  T: TTest;
  I: ITest;
begin
  ShowMessage('create-o');
  T := TTest.Create;
  ShowMessage('Test1-o');
  TTest.Test1(T);
  ShowMessage('Test2-o');
  TTest.Test2(T);

  ShowMessage('I:=');
  I := T;
  ShowMessage('Test1-i');
  TTest.Test1(I);
  ShowMessage('Test2-i');
  TTest.Test2(I);
  ShowMessage('nil');
  I := nil;

  ShowMessage('Free');
  T.Free;

  ShowMessage('create-i');
  I := TTest.Create;
  ShowMessage('nil');
  I := nil;

  ShowMessage('End');
end;

[Elvis]

Zitat:

Zitat von himitsu (Beitrag 1187931)

Aber nur doch wenn man schon eine Interface-Referenz hat, welche man da übergeben kann.
Wenn erst soeine Instanz erstellt werden muß, dann sollte diese auch mit gezählt werden, da sie vor der Übergabe lokl in einer temporären Variable zwischengespeichert wird. :gruebel:

"const" scheint hier eine Eigenart zu sein, da hierbei keine Zuweisungen passieren können.
Deshalb muss da kein _AddRef oder _Release ausgeführt werden.
Diese 2 Methoden werden innnerhalb von DoSomething aufgerufen, nicht davor/danach. Dass hierbei etwas temporär irgendwo abgelegt wird ist doch unerheblich?

Zitat:

[edit]
Das überrascht mich jetzt aber, da ist wirklich kein AddRef :shock:

Ohne const hätten sie sich Interfaces fast sparen können...