Was nervt euch so, während der Programmierung oder so allgemein

[Stevie]

Zitat von himitsu:

Extrem nerven tut es, daß _AddRef und _Release nie als virtual deklariert sind. (QueryInterface ist es allerdings fast immer)

Wie soll man denn da nachträglich eine Referenzzählung implementieren, wo es vorher keine gab (diese Funktionen machen nichts), bzw. wie soll man da das Verhalten ändern können.

Überschreib die Methoden und setz in die Klassendefinition nochmals IInterface. Dann werden die 3 Methoden aus dieser Klasse benutzt.

[Meflin]

Digital River. Nie wieder!

[himitsu]

Hi Stevie,

seit man aber Interfaces wieder in Objekte zurückcasten kann (IInterfaceComponentReference sei Dank ... die haben mir meine Idee geklaut ),
ist dieses nicht mehr sicher, denn wenn man dann auf das ältere Klasse castet und dann wieder in ein Interface, dann wird das Interface des Vorfahren und nicht das Neue verwendet.

Und IInterfaceComponentReference zu überschreiben hatte keinerlei Wirkung, sonst hätt' ich da einfach NIL zurückgegeben.

Delphi-Quellcode:

type
  TMyClass1 = class(TObject, IInterface)
    function QueryInterface(const IID: TGUID; out Obj): HResult; virtual; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

  TMyClass2 = class(TMyClass1, IInterface)
    function QueryInterface(const IID: TGUID; out Obj): HResult; override; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
  end;

procedure TForm1.FormCreate(Sender: TObject);
var
  i1, i2, i3, i4, i5, i6: IInterface;
  o5: TMyClass1;
  o6: TMyClass2;
begin
  Memo1.Lines.Add('');
  Memo1.Lines.Add('o6 := TMyClass2.Create / i6 := TMyClass2(o6) as IInterface');
  o6 := TMyClass2.Create;
  i6 := o6 as IInterface;
  i6._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('o5 := TMyClass2.Create; / i5 := TMyClass1(o5) as IInterface;');
  o5 := TMyClass2.Create;
  i5 := o5 as IInterface;
  i5._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i1 := TMyClass1.Create;');
  i1 := TMyClass1.Create;
  i1._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i2 := TMyClass2.Create;');
  i2 := TMyClass2.Create;
  i2._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i3 := TMyClass2(i2) as TMyClass2;');
  i3 := i2 as TMyClass2;
  i3._AddRef;

  Memo1.Lines.Add('');
  Memo1.Lines.Add('i4 := TMyClass2(i2) as TMyClass1;');
  i4 := i2 as TMyClass1;
  i4._AddRef;

  Memo1.Lines.Add('');
end;

{ TMyClass1 }

function TMyClass1.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  Form1.Memo1.Lines.Add('TMyClass1.QueryInterface');
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TMyClass1._AddRef: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass1._AddRef');
end;

function TMyClass1._Release: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass1._Release');
end;

{ TMyClass2 }

function TMyClass2.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  Form1.Memo1.Lines.Add('TMyClass2.QueryInterface');
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TMyClass2._AddRef: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass2._AddRef');
end;

function TMyClass2._Release: Integer;
begin
  Form1.Memo1.Lines.Add('TMyClass2._Release');
end;

end.




o6 := TMyClass2.Create / i6 := TMyClass2(o6) as IInterface
TMyClass2.QueryInterface
TMyClass2._AddRef
TMyClass2._AddRef

o5 := TMyClass2.Create; / i5 := TMyClass1(o5) as IInterface;
TMyClass1.QueryInterface    // ist QueryInterface nicht virtual kommt hier TMyClass1.QueryInterface rause
TMyClass2._AddRef
TMyClass2._AddRef

i1 := TMyClass1.Create;
TMyClass1._AddRef
TMyClass1._AddRef

i2 := TMyClass2.Create;
TMyClass2._AddRef
TMyClass2._AddRef

i3 := TMyClass2(i2) as TMyClass2;
TMyClass2.QueryInterface
TMyClass2._AddRef
TMyClass2._AddRef

i4 := TMyClass2(i2) as TMyClass1;
TMyClass2.QueryInterface
TMyClass1._AddRef
TMyClass1._AddRef

TMyClass2._Release
TMyClass2._Release
TMyClass1._Release
TMyClass2._Release
TMyClass2._Release
TMyClass1._Release

[haentschman]

@himi...

wenn wir hier einen Counter hätten, würdest du den genervten Record halten... Paß auf deine Gesundheit auf, damit nicht in ein paar Jahren ein Bypaß dich verschönert Man muß sich nicht über alles aufregen. Manchmal einfach nur akzeptieren...

[Stevie]

Zitat von himitsu:

seit man aber Interfaces wieder in Objekte zurückcasten kann (IInterfaceComponentReference sei Dank ... die haben mir meine Idee geklaut ),
ist dieses nicht mehr sicher, denn wenn man dann auf das ältere Klasse castet und dann wieder in ein Interface, dann wird das Interface des Vorfahren und nicht das Neue verwendet.

So ne Schei... macht man ja auch nicht! Oder man schaltet sein Hirn an bevor man wirres Zeugs codet.

[himitsu]

Die Klasse ist für etwas, was hier mal veröffentlicht wird ... Und was hier für Irre rumlaufen, kann ich mir jetzt noch garnicht ausdenken.
Allerdings könnte man sich über diese Lib die Delphi-IDE lahmlegen und das wollte ich minimieren.

[Stevie]

Dass man non ref counted interfaces haben will, ist ja noch plausibel, aber dass man TComponent Derivate mit Refcounting ausstatten will, kann ich nicht ganz verstehen, denn genau damit kannst du ganz böse Überraschungen erleben. Das TComponent livetime management wird nunmal über den Owner geregelt und nicht über das Interface. Beides zu mischen wird über kurz oder lang in die Hose gehen.

[himitsu]

Deswegen hab ich mir ja ein entsprechendes Verhalten ausgedacht, welches den Referenzzähler und die Objektreferenz beachtet ... erst wenn Beides freigeben ist, wird alles aufgeräumt.

Denn es ist vorgesehn diese Klassen gleichzeitig in der VCL und als Interface zu nutzen und ich wollte mir eben doppelte Arbeit ersparen, das als Interface zu machen und dann nochmal 'ne Containerklasse für die VCL bereitzustellen.