TWinControl via TInterfacedObject via TInterfacedPersistent

[TiGü]

Zitat:

Zitat von Zacherl (Beitrag 1404268)

...sondern ein Programmierfehler sein, oder liege ich hier falsch?

Das kann man hier natürlich nicht ausschließen. :wink:

[EWeiss]

Delphi-Quellcode:

begin
   RegisterAudioSessionNotification(FProxy);
   UnregisterAudioSessionNotification(FProxy);
end; { bumm, wenn diese Methode verlassen wird, denn wird FProxy zerstört }

Genau so habe ich es umgesetzt also self mit FProxy ersetzt.
Dann die ganzen OnEvents.. nach TAudioVolumeProxy portiert.

Da die ganzen Events strict private sind konnte ich von außen die Events nicht mehr zuweisen.
Danach habe ich es dann gelassen ;)

Alle zugriffe in den Funktionen OnEvents habe ich dann mit FOwner angesprochen.

gruss

[Zacherl]

Zitat:

Zitat von Schokohase (Beitrag 1404274)

Wenn du dir selber aber die Interface Referenz nicht merkst [...] und du gibst eine Interface-Referenz davon heraus, dann tickt ab da die RefCount-Bombe und die kann zu jedem Zeitpunkt platzen.

Stimmt, das hatte ich nicht bedacht :?

Generell sollte es aber doch trotzdem möglich sein (wenn man sich dann eben 1 Interface-Referenz merkt), ein Leaken zu vermeiden, wenn man entsprechende

Delphi-Quellcode:

AddRef

und

Delphi-Quellcode:

Release

Aufrufe immer ausschließlich in Paaren ausführt. Ich vermute, dass hier einfach irgendwo ein paar versteckte

Delphi-Quellcode:

AddRef

Aufrufe stattfinden (z.B. innerhalb eines API Calls) zu denen es kein

Delphi-Quellcode:

Release

gibt.

Zitat:

Zitat von EWeiss (Beitrag 1404286)

[Genau so habe ich es umgesetzt also self mit FProxy ersetzt.
Dann die ganzen OnEvents.. nach TAudioVolumeProxy portiert.

Da die ganzen Events strict private sind konnte ich von außen die Events nicht mehr zuweisen.
Danach habe ich es dann gelassen ;)

Jaa, also das

Delphi-Quellcode:

strict

kannst du auch weglassen, aber muss zugeben, dass ich die Komponente auch nicht in ihrer Gesamtheit angeschaut habe, weshalb ich nicht weiß, ob es den Aufwand wert ist.

Was du allerdings mal machen könntest, ist

Delphi-Quellcode:

AddRef

und

Delphi-Quellcode:

Release

zu überschreiben und Breakpoints zu setzen. Dann kannst du vielleicht nachvollziehen, wo es zu Aufrufen von

Delphi-Quellcode:

AddRef

kommt, ohne dass danach

Delphi-Quellcode:

Release

aufgerufen wird.

[Schokohase]

Hier mal ein Beispiel, wie so etwas gehen kann

Delphi-Quellcode:

type
  IFoo = interface ['{a895c8b4-db8c-40e9-a907-a0a4b01ff773}']
    procedure Bar;
  end;

  TFooImplementer = class(TObject,IFoo)
  private type
    IFooProxy = interface(IFoo) ['{20920822-173c-4e67-8f7b-8959366cc6b2}']
      procedure Release;
    end;
  strict private
    FProxy: IFooProxy;
    function GetFoo: IFoo;
  strict protected
    property Foo: IFoo read GetFoo implements IFoo;
  public
    constructor Create;
    destructor Destroy; override;

    procedure Bar; // Die Methode macht die echte Arbeit
  end;

  TInterfacedFooProxy = class(TInterfacedObject, IFoo, TFooImplementer.IFooProxy)
  strict private
    FFoo: TFooImplementer;
  strict protected
    procedure Bar;
  strict protected
    procedure Release;
  public
    constructor Create(AFoo: TFooImplementer );
    destructor Destroy; override;
  end;

  { TFooImplementer }

procedure TFooImplementer.Bar;
begin
  WriteLn('*** TFooImplementer.Bar ***');
end;

constructor TFooImplementer.Create;
begin
  inherited Create;
  FProxy := TInterfacedFooProxy.Create(Self);
end;

destructor TFooImplementer.Destroy;
begin
  WriteLn('TFooImplementer.Destroy');
  FProxy.Release;
  inherited;
end;

function TFooImplementer.GetFoo: IFoo;
begin
  Result := FProxy;
end;

{ TInterfacedFooProxy }

procedure TInterfacedFooProxy.Bar;
begin
  WriteLn('TInterfacedFooProxy.Bar');
  if Assigned(FFoo)
  then
    FFoo.Bar;
end;

constructor TInterfacedFooProxy.Create(AFoo: TFooImplementer);
begin
  inherited Create;
  FFoo := AFoo;
end;

destructor TInterfacedFooProxy.Destroy;
begin
  WriteLn('TInterfacedFooProxy.Destroy');
  inherited;
end;

procedure TInterfacedFooProxy.Release;
begin
  FFoo := nil;
end;

und ein kleiner Test dazu

Delphi-Quellcode:

procedure Main;
var
  fooObj : TFooImplementer;
  fooIntf: IFoo;
begin
  fooObj := TFooImplementer.Create;
  try
    fooIntf := fooObj;
    // direkter Aufruf
    fooObj.Bar;
    // indirekter Aufruf durch IFoo
    fooIntf.Bar;
  finally
    fooObj.Free;
    fooObj := nil;
  end;

  // indirekter Aufruf durch IFoo, der aber ins Leere geht
  fooIntf.Bar;
  fooIntf := nil;
end;

und was dabei herauskommt

Code:

*** TFooImplementer.Bar ***
TInterfacedFooProxy.Bar
*** TFooImplementer.Bar ***
TFooImplementer.Destroy
TInterfacedFooProxy.Bar
TInterfacedFooProxy.Destroy