Umgang mit Interfaces

[Der schöne Günther]

Zitat von himitsu:

Nur voll bescheuert, daß die Codevervollständigung nur nach Wortanfängen sucht und man jetzt nix mehr findet.

Nicht nur das, auch das (sowieso nur sporadisch funktionierende) "Inkludiere mir die passende Unit" mittels Strg+Shift+A. Muss man halt immer auswendig lernen, in welchen Units die jeweiligen Klassen so stecken. Oder man geht sich erstmal einen Kaffee holen während die dexplore-Hilfe bzw. die superschnellen Embarcadero-Server laden (und nichts finden).

Mutet zwar im Jahr 2013 etwas komsich an, aber irgendwie muss man seinen Kopf ja auch trainieren

[TiGü]

Zitat von TiGü:

Für deine Zwecke wäre sogar ein generisches TDictionary besser, da du ja irgendwie auf die Objekte per Namen zugreifen willst (siehe TListData.fName).

Mal ein Beispiel, als Keys des Dictonarys (auch Map genannt) kann man vielleicht auch die GUID der Interfaces nehmen:

Delphi-Quellcode:

unit Unit2;

interface

uses
  Winapi.Windows,
  Winapi.Messages,
  System.SysUtils,
  System.Variants,
  System.Classes,
  Vcl.Graphics,
  Vcl.Controls,
  Vcl.Forms,
  Vcl.Dialogs,
  System.Generics.Collections,
  Vcl.StdCtrls;

type
  IBase = Interface(IUnknown)
    function GetCanSave : Boolean;
  end;

  IValue = Interface(IBase)
    function GetIsNaN : Boolean;
  End;

  IInteger = Interface(IValue)
    function GetValue : Integer;
    procedure SetValue(const AValue : Integer);
  End;

  ICompare = Interface(IBase)
    function Compare : Boolean;
  End;

  ISomeThing = Interface(IBase)
    function DoSomeThing : Integer;
  End;

  TMyBase = Class(TInterfacedObject, IBase)
  public
    function GetCanSave : Boolean;
  End;

  TMyInteger = Class(TMyBase, IInteger)
  public
    function GetValue : Integer;
    procedure SetValue(const AValue : Integer);
    function GetIsNaN : Boolean;
  End;

  TMyCompare = Class(TMyBase, ICompare)
  public
    function Compare : Boolean;
  End;

  TMyDoSomething = Class(TMyCompare, IInteger, ISomeThing)
  public
    function DoSomeThing : Integer;
    function GetValue : Integer;
    procedure SetValue(const AValue : Integer);
    function GetIsNaN : Boolean;
  End;

  TForm2 = class(TForm)
    Button1 : TButton;
    procedure FormCreate(Sender : TObject);
    procedure Button1Click(Sender : TObject);
  private
    { Private declarations }
    fList : TDictionary<string, IBase>;
  public
    { Public declarations }
  end;

var
  Form2 : TForm2;

implementation

{$R *.dfm}

{ TMyCompare }

function TMyCompare.Compare : Boolean;
begin

end;

{ TMyInteger }

function TMyInteger.GetIsNaN : Boolean;
begin
  //
end;

function TMyInteger.GetValue : Integer;
begin
  //
end;

procedure TMyInteger.SetValue(const AValue : Integer);
begin
  //
end;

{ TMyDoSomething }

function TMyDoSomething.DoSomeThing : Integer;
begin
  //
end;

function TMyDoSomething.GetIsNaN : Boolean;
begin
  //
end;

function TMyDoSomething.GetValue : Integer;
begin
  //
end;

procedure TMyDoSomething.SetValue(const AValue : Integer);
begin
  //
end;

{ TMyBase }

function TMyBase.GetCanSave : Boolean;
begin
  //
end;

procedure TForm2.FormCreate(Sender : TObject);
begin
  fList := TDictionary<string, IBase>.Create;

  fList.Add(TMyInteger.ClassName , TMyInteger.Create);
  fList.Add(TMyCompare.ClassName , TMyCompare.Create);
  fList.Add(TMyDoSomething.ClassName , TMyDoSomething.Create);
end;

procedure TForm2.Button1Click(Sender : TObject);
var
  MyObject : IBase;
begin
  if fList.TryGetValue(TMyDoSomething.ClassName, MyObject) then
  begin
    IInteger(MyObject).SetValue(1);
    ISomeThing(MyObject).DoSomeThing;
  end;

  if fList.TryGetValue(TMyInteger.ClassName, MyObject) then
  begin
    IInteger(MyObject).SetValue(2);
  end;

  if fList.TryGetValue(TMyCompare.ClassName, MyObject) then
  begin
    ICompare(MyObject).Compare;
  end;
end;

end.

[himitsu]

Zitat von TiGü:

Die Referenzzählung selber verursacht die Schutzverletzung nicht, sondern der fehlerhafte Umgang mit Interfaceobjekten.

Jupp, die funktioniert so, wie sie soll.

Aber, sobald von einem "referenzzählenden" Objekt eine Interface-Referenz "erzeugt" wurde, dann übernimmt die Referenzzählung die Kontrolle über die Speicherverwaltung.
Sobald dann die letzte Referenz weg ist, wird das Objekt freigegeben und dein Objektzeiger wird ungültig.
Ohne Interfacereferenzen bleibt die Speicherfreigabe dem .Free überlassen.

Darum war auch mein Tipp:
Wenn mit "referenzzählenden" Interfaces gearbeitet werden soll, dann möglichst durchgehend nur noch mit Interface-Referenzen arbeiten
und wenn Objekt-Referenzen nötig sind, dann muß man dort eben aufpassen.

[Uwe Raabe]

Zitat von Der schöne Günther:

Zitat von himitsu:

Nur voll bescheuert, daß die Codevervollständigung nur nach Wortanfängen sucht und man jetzt nix mehr findet.

Nicht nur das, auch das (sowieso nur sporadisch funktionierende) "Inkludiere mir die passende Unit" mittels Strg+Shift+A. Muss man halt immer auswendig lernen, in welchen Units die jeweiligen Klassen so stecken. Oder man geht sich erstmal einen Kaffee holen während die dexplore-Hilfe bzw. die superschnellen Embarcadero-Server laden (und nichts finden).

Mutet zwar im Jahr 2013 etwas komsich an, aber irgendwie muss man seinen Kopf ja auch trainieren

Oder man verwendet gleich den ModelMaker CodeExplorer...

[Der schöne Günther]

Ja ich weiß - Das Teil ist sein Geld wirklich mehr als wert.

Nach dem letzten Einkauf (TChart Pro) will ich vorerst nicht schon wieder laut nach weiteren Investitionen schreien

Vorerst

[Whookie]

Zitat von jaenicke:

So nach dem Motto würde ich das machen, ungetestet:

Delphi-Quellcode:

TMyList = class
  private
    var
      FList: TList<IListData>;
  public
    function Get<T: IInterface>(const AIndex: Integer): T;
  end;

...
function TMyList.Get<T>(const AIndex: Integer): T;
begin
  if not Supports(FList[AIndex], Result) then
    Result := nil;

Ich fürchte mein Verständnis für Interfaces und Generics reicht nicht aus um das Beispiel nachzuvollziehen... IListData als Typ der Liste hätte ich noch als Tippfehler gesehen sodass daraus FList:TList<TListData>; wird?

Die Get-Funktion wird dann zu:

Delphi-Quellcode:

function TMyList.Get<T>(const AIndex: Integer): T;
begin
  if not Supports(FList[AIndex].fMy, Result) then  //<- Error
    Result := nil;  
end;

wobei das Resultat auf IInterface-Support eingeschränkt wird(?). Da man aber Supports nicht ohne eine IID_xxx aufzurufen kann, muss man hier wieder ein konkretes Interface angeben. Also etwa:

Delphi-Quellcode:

function TMyList.Get<T>(const AIndex: Integer): T;
begin
  if not Supports(FList[AIndex].fMy, IID_BASE, Result) then
    Result := nil;    
end;

Womit eigentlich nur mehr das IBase-Interface von der Funktion zu haben wäre? Ausprobieren konnte ich das ganze nicht, denn obwohl sich der Code der Liste compilieren lässt, bekomme ich dann bei einem Zugriffsversuch vom Compiler die Meldung: "E2531 Methode 'Get' erfordert explizite Typargumente", was eventuell daran liegt, dass ich keinen korrekten Aufruf hinbekommen habe..

Code:

  i: IBase;

  i := fMyList.Get(0);
  i := fMyList.Get(0) As IBase;
  ...

Wünschen würde ich mir ja eher sowas wie:

Delphi-Quellcode:

Var
  iSom: ISomeThing;
  iInt: IInteger;
begin
  for i := 0 To fMyList.Count-1 Do
  begin
    if fMyList.Get(i, iInt) Then
      iInt.SetValue(Random(100));
    if fMyList.Get(0, iSom) Then
      iSom.DoSomething;
    ..

Unabhängig von der korrekten Implementierung frage ich mich auch noch wie die Performanz hier aussieht. Es werden ja ständig Interfaces über Strings gesucht?

[TiGü]

Zitat von Whookie:

Da man aber Supports nicht ohne eine IID_xxx aufzurufen kann, muss man hier wieder ein konkretes Interface angeben. Also etwa:

Delphi-Quellcode:

function TMyList.Get<T>(const AIndex: Integer): T;
begin
  if not Supports(FList[AIndex].fMy, IID_BASE, Result) then
    Result := nil;    
end;

Das ist so nicht richtig, siehe Doku:

Delphi-Quellcode:

function Supports(const Instance: IInterface; const IID: TGUID; out Intf): Boolean;
function Supports(const Instance: TObject; const IID: TGUID; out Intf): Boolean;
function Supports(const Instance: IInterface; const IID: TGUID): Boolean;
function Supports(const Instance: TObject; const IID: TGUID): Boolean;
function Supports(const AClass: TClass; const IID: TGUID): Boolean;

Wobei IID hier auch direkt ein Interface-Typ sein kann (IMyFunnyInterface, IInteger, IDoSomeThing).

Codebeispiel anhand deines Falls:

Delphi-Quellcode:

type
  TMyDoSomething = Class(TMyCompare, IInteger, ISomeThing)
  ...
  end;

var
  MySomeThingObject : ISomeThing;
begin
  MySomeThingObject := TMyDoSomething.Create;
  if Supports(MySomeThingObject, IInteger) then
  begin
    ShowMessage('IInteger wird voll unterstützt!!!');
  end;
end;

[Whookie]

Zitat von TiGü:

Delphi-Quellcode:

  ...
var
  MySomeThingObject : ISomeThing;
begin
  MySomeThingObject := TMyDoSomething.Create;
  if Supports(MySomeThingObject, IInteger) then
  begin
    ShowMessage('IInteger wird voll unterstützt!!!');
  end;
end;

... und laut Doku ist das Objekt damit auch zerstört und damit kann man diese Variante nicht verwenden...

Edit: Habe nicht erwähnt das ich meine Klassen nicht als Interface speichern kann (ISomeThing muss zu TSomeThing werden), weil ich eben eine "Basisliste" mit allen Klassen habe. Diese stehen untereinander in verschiedenen Beziehungen und pflegen daher eigene TNodeList-en um eine Referenz auf diese benötigten Instanzen zu haben. Durch diese Verlinkung schnellt der _RefCount bei verwendung von Interfaces aber hoch und am Programmende, wenn die "Basisliste"-alles frei gibt, bleibt ein riesiges Memoryleek über.

[jaenicke]

Zitat von Whookie:

Edit: Habe nicht erwähnt das ich meine Klassen nicht als Interface speichern kann (ISomeThing muss zu TSomeThing werden), weil ich eben eine "Basisliste" mit allen Klassen habe.

Das ist dann keine gute Architektur, lässt sich aber bei Einführung von Interfaces in alte Quelltexte manchmal nicht vermeiden. In neuen Quelltexten ist das allerdings ein No-Go.

Dann solltest du die Referenzzählung auf jeden Fall in allen Objekten deaktivieren. Es macht keinerlei Sinn die zu nutzen, wenn du nicht durchgängig mit Interfaces arbeitest.

Das haben wir als Notlösung bei der Umstellung in alten Quelltexten vorübergehend auch gemacht, sind aber mittlerweile so weit, dass wir es größtenteils richtig, sprich nur mit Interfaces, umgesetzt haben. Das ist bei Verwendung von Interfaces ja die einzige sinnvolle Variante.

[JamesTKirk]

Zitat von Whookie:

Habe nicht erwähnt das ich meine Klassen nicht als Interface speichern kann (ISomeThing muss zu TSomeThing werden), weil ich eben eine "Basisliste" mit allen Klassen habe.

Du könntest mal probieren, ob's richtig funktioniert, wenn du bei deinen Klassen explizit _AddRef aufrufst, bevor du es in deine Liste speicherst. Damit sagst du der Referenzzählung ja, dass da noch eine Referenz ist. Bevor du die Klasse dann freigibst musst du diese Referenz dann wieder mit _Release lösen und wenn keine andere Referenz auf eines der Interfaces der Klasse vorhanden ist, sollte sie auch gleich automatisch freigegeben werden.

Gruß,
Sven