TWinControl via TInterfacedObject via TInterfacedPersistent

[TiGü]

Zitat von Zacherl:

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

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

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

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 AddRef und Release Aufrufe immer ausschließlich in Paaren ausführt. Ich vermute, dass hier einfach irgendwo ein paar versteckte AddRef Aufrufe stattfinden (z.B. innerhalb eines API Calls) zu denen es kein Release gibt.

Zitat von EWeiss:

[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 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 AddRef und Release zu überschreiben und Breakpoints zu setzen. Dann kannst du vielleicht nachvollziehen, wo es zu Aufrufen von AddRef kommt, ohne dass danach 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