Data-Pointer in Interfacevariable casten

[RedOne]

Hallo zusammen
Die Delphi-Interfaces bringen mich gerade an den Rand der verzweiflung...

Ich habe folgenden Code:

Delphi-Quellcode:

var
  i: IDataObject;
begin
  if ListViewMain.ItemIndex >= 0 then begin
    i:= ListViewMain.Selected.Data as IDataObject;
    FillForm( i );
  end
end;

Im Data werden verschiedene Objekte abgelegt die alle dieses Interface implementieren.
Dieser Code gibt ein Compillerfehler (E2015 Operator ist auf diesen Operandentyp nicht anwendbar).
Caste ich mit IDataObject( ListViewMain.Selected.Data ) gibt es mir einen Laufzeitfehler (Data ist Assigned).

Wo liegt den hier das Problem?
Merci

[himitsu]

Ein Pointer ist halt kein Interface.

Delphi-Quellcode:

i := IDataObject(ListViewMain.Selected.Data);
// oder
i := Interface(ListViewMain.Selected.Data) as IDataObject;

PS: Wie regelst du denn die Referenzzählung?
Wenn keine andereren Referenzen auf das Interface bestehen und du dieses nicht beachtest, dann würde das Interface freigegeben, auch wenn du dieses hier verlinkt hast, falls du keine Referenz hierfür beantragst.

Delphi-Quellcode:

// zuweisen
ListViewMain.Selected.Data := Pointer(DataObject);
DataObject._AddRef;

// vorm freigeben 
DataObject.__Release;

[RedOne]

Merci für Deine Antwort.
Mit

Delphi-Quellcode:

i:= IDataObject( ListViewMain.Selected.Data );

wird bei dieser Zeile eine Exception geworfen (Zugriffsverletzung) obwohl das Objekt existiert und auch instanziert ist (habs zur Sicherheit nochmals getestet).
Casten mit

Delphi-Quellcode:

i:= Interface(ListViewMain.Selected.Data) as IDataObject;

ergibt einen Compilerfehler...

Das Objekt (TAccountDataExtend) im Data implementiert eine weitere Klasse (TAccountData) und das Interface. TInterfacedObject implementiere ich schon auf der implementierten Klasse TAccountData. Ich nehme an, dies sollte schon funktionieren? Ein anderer Weg ist mir (bisher) noch nicht bekannt.

Delphi-Quellcode:

TAccountData = class( TInterfacedObject )[...]
TAccountDataExtend = class( TAccountData, IDataObject ) [...]

Die Frage betreffend der Referenzzählung ist gut :-)
In Delphi habe ich bisher nicht das Glück gehabt mit Interfaces zu arbeiten. Da bin ich wohl ein bisschen .Net verwöhnt bei dem dies keine Rolle spielt :-)

Herzlichen Dank
RedOne

[himitsu]

Ups, meinte natürlich IInterface

Delphi-Quellcode:

i:= IInterface(ListViewMain.Selected.Data) as IDataObject;

.

Es sah allerdings so aus, als wenn das Interface direkt im .Data drin ist, bzw. es klang irgendwie danach.
Aber wenn es das Objekt ist, dann mußt du .Data natürlich in Diese casten.

Delphi-Quellcode:

i := TAccountDataExtend(ListViewMain.Selected.Data) as IDataObject;

[RedOne]

Das geht ja flux mit Antworten... :-) Merci!

Delphi-Quellcode:

i:= IInterface(ListViewMain.Selected.Data) as IDataObject;

compilliert zwar aber gibt immer noch einen Laufzeitfehler.
Gerne würde ich direkt in mein TAccountData casten, kann ich aber nicht:
Ich habe ein abstraktes Basisformular da alle Editierfenster den gleichen Aufbau besitzen.
Nun habe ich ein AccountForm davon abgeleitet. Dieses rufe ich auf und fülle beim Start eine Listview (auf Basisklasse vorhanden) mit meinen TAccountDataExtend's.
Wird ein Datensatz angeklickt und auf den Löschbutton geklickt, so wird auf Stufe des Basisformulares, dass keine Ahnung hat um was für ein Objekt es sich handelt, das Objekt im Data auf mein IDataObject-Interface gecastet und die Funktion "Delete" aufgerufen, die wegen dieses Interfaces auf meinem TAccountDataExtend implementiert sein muss.
Aber auf Stufe des Basisformulares weiss ich nicht was für ein konkretes Objekt sich in der Listview befindet. Allerdings weiss ich dass jedes Objekt die genannte "Delete"-Funktion implementiert, da diese ja von diesem Interface abgeleitet sind.

Wenn ich die Klasse für TAccountDataExtend zu Testzwecken auf Stufe des Basisformulars einbinde und caste sehe ich dass dieses Objekt existiert und kann auch die Deletefunktion aufrufen. Darum bin ich ein bisschen verwirrt wieso ich mein Data-Pointer nicht in dieses Interface casten kann, respektive wieso mir dieser Hund eine Exception wirft :-)

Herzlichen Dank

Ps.
Einige Auszüge aus dem Code. Das beim "OnChange"-Ereignis gelöscht wird macht weniger Sinn. Dies ist mehr zum Verständnis

Delphi-Quellcode:

//-------- TFormEditBase 
TFormEditBase = class( TForm )
  procedure ListViewMainChange( _sender: TObject; _item: TListItem; _change: TItemChange );
  ...
end;

procedure TFormEditBase.ListViewMainChange( _sender: TObject; _item: TListItem; _change: TItemChange );
var
  i: IDataObject;
begin
  if ListViewMain.ItemIndex >= 0 then begin
    i:= IInterface(ListViewMain.Selected.Data) as IDataObject;
    i.Delete;
  end;
end {ListViewMainChange};

//-------- TFormAccounts 
TFormAccounts = class( TFormEditBase )
  procedure Load;
  ...
end;

procedure TFormAccounts.Load;
var
  tmp: TAccountDataExtend;
  obj: TObjectList;
  i: Integer;
  item: TListItem;
begin
  GetAllAccounts( obj );
  try
    for i:= 0 to obj.Count - 1 do begin
      tmp:= obj[ i ] as TAccountDataExtend;
      item:= ListViewMain.Items.Add;
      item.SubItems.Add( tmp.Name );
      item.Data:= tmp;
    end;
  finally
    obj.Free;
  end;
end;

[brechi]

Erstmal grundsätzlich: Speicher sollte dort freigegeben werden wo man diesen auch initialisiert hat :)

Delphi-Quellcode:

var
  obj: TObjectList;
begin
  obj := TObjectList.Create;
  try
    GetAllAccounts( obj );
    ...
  finally
    obj.Free;
  end;
end;

Dann zu deinem Problem:

1) warum verwendest du eine Objektlist wenn du mit Interfaces arbeitest? Gibt auch eine TInterfaceList
2) wenn du eine ObjectList verwendest, ist auch OwnsObjects auf false, sonst sind die Objekte beim Free alle wieder weg (auch deine TInterfaceObjects)

Bei Item.Data solltest du dann auch das Interface angeben und den Referenzcounter erhöhen. Hier mal ein Beispiel hoffe das ist jetzt so korrekt und du kannst was damit anfangen

Delphi-Quellcode:

type
  IIrgendwas = interface ['{0EF386E9-7F06-4D9A-A261-37D61BE3F8BE}']
    procedure MessageBox;
  end;

  TMyObject = class(TInterfacedObject, IIrgendwas)
    procedure MessageBox;
  end;

procedure TForm6.FormCreate(Sender: TObject);
var
  x: TInterfaceList;
  obj, obj2: IInterface;
  obj3: IIrgendwas;
  sl: TStringList;
  i: integer;
begin
  obj := TMyObject.Create;

  sl := TStringList.Create;
  try
    x := TInterfaceList.Create; // statt der ObjectList
    try
      x.Add(obj); 
      for i := 0 to x.Count - 1 do begin
        sl.Add('test');
        obj._AddRef; // ein cast als Pointer bekommt Delphi nicht mit (dein data)
        sl.Objects[i] := Pointer(obj);
      end;       
    finally
      FreeAndNil(x);
    end;

  obj := nil;

  // verwenden und freigeben
  obj2 := IInterface(Pointer(sl.Objects[0]));
  if Succeeded(obj2.QueryInterface(IIrgendwas, obj3)) then
    obj3.MessageBox;
  obj2._Release;
  finally
    FreeAndNil(sL);
  end;

end;

{ TMyObject }

procedure TMyObject.MessageBox;
begin
  MessageBoxA(0, 'test', nil, 0)
end;

[RedOne]

Merci für Deine Antwort. Wir kommen näher ;-)

Der Speicher wird vor der Funktion initialisiert. Ich habe den Code zusammengestrichen, da ist sie mir wohl abhanden gekommen :-)

Zitat:

1) warum verwendest du eine Objektlist wenn du mit Interfaces arbeitest? Gibt auch eine TInterfaceList

Weil ich diese bisher nicht kannte :-)

Zitat:

2) wenn du eine ObjectList verwendest, ist auch OwnsObjects auf false, sonst sind die Objekte beim Free alle wieder weg (auch deine TInterfaceObjects)

OwnsObject setzte ich bis anhin in der Funktion auf false

Ich habe das ganze jetzt mal gemäss Deinem Beispiel umgebaut und es funktioniert fast. Weder gibt es einen Compillier- noch einen Laufzeitfehler :-)
In der Methode "Delete" gebe zu Testzwecken FID aus. Diese ist jedoch immer 0. Beim abfüllen beziehe ich den Text für die Listview direkt aus dem Objekt, die ID ist also beim Start definitiv gesetzt.

Verkürzter Code:

Delphi-Quellcode:

IDataObject = interface( IInterface )
  ['{C94DCAC7-CA42-45D3-95D7-9BC321BA2E2A}']
  procedure Delete;
end;

TAccountData = class( TInterfacedObject )
protected
  FID: Integer;
public
  property ID: Integer read FID write FID;
end;

TAccountDataExtend = class( TAccountData, IDataObject )
public
  procedure Delete;
end;

procedure TFormAccounts.Refresh;
var
  tmp: IInterface;
  i: Integer;
  item: TListItem;
  x: TInterfaceList;
begin   
  //Vorgängig Listview aufräumen, Objekte zerstören, Interface Releasen
         
  x:= TInterfaceList.Create;
  try
    GetAllAccounts( x ); //Siehe Funktion unten
    for i:= 0 to x.Count - 1 do begin
      tmp:= x[ i ];
      item:= ListViewMain.Items.Add;
      item.Caption:= IntToStr( TAccountDataExtend( tmp ).ID ); //Zeigt korrekte ID an
      item.Data:= Pointer( tmp );
    end;
  finally
    FreeAndNil( x ); //Ich nehme an die InterfaceList zerstört die Objekte nicht
  end;
end {LoadListView};

procedure GetAllAccounts( _o: TInterfaceList );
var
  tmp: IDataObject;//Oder IInterface?
begin
  for i:= 0 to 4 do begin
    tmp:= TAccountDataExtend.Create;
    TAccountDataExtend( tmp ).FID:= i;
    tmp._AddRef;
    _o.Add( tmp );
  end;
end {GetAllAccounts};


procedure TFormEditBase.ListViewMainClick(Sender: TObject);
var
  obj: IInterface;
  obj3: IDataObject;
begin
  Inherited;
  if ListViewMain.ItemIndex >= 0 then begin
    obj:= IInterface( Pointer( ListViewMain.Selected.Data ));
    if Succeeded( obj.QueryInterface( IDataObject, obj3 )) then begin
      obj3.Delete; //Funktion siehe unten
    end;
  end;
end;

//----------------- TAccountDataExtend
procedure TAccountDataExtend.Delete;
begin
  ShowMessage( IntToStr( FID )); //Gibt immer "0" aus
end {Delete};

Vielen Dank
RedOne

[himitsu]

Delphi-Quellcode:

tmp._AddRef;

brauchst du bei einer InterfaceList nicht, da diese die Referenzzählung schon richtig behandelt.

also ab Delphi 2010 soll es ja nun so gehn (davor gibt es keinen offiziellen Weg, um aus einen Interface wieder ein Objekt zu machen)
> aber sowas würde ich hier nicht machen

Delphi-Quellcode:

var tmp: IInterface;

tmp:= TAccountDataExtend.Create;
(tmp as TAccountDataExtend).FID:= i;
_o.Add( tmp );

oder es erst noch als Objekt belassen und dann direkt übergeben (später umwandeln lassen)

Delphi-Quellcode:

var tmp: TAccountDataExtend;

tmp := TAccountDataExtend.Create;
tmp.FID:= i;
// aber tmp nicht zwischenzeitlich als Interface verwenden!!!
_o.Add( tmp );

oder es erst noch als Objekt belassen und später in ein Interface umwandeln

Delphi-Quellcode:

var otmp: TAccountDataExtend;
  tmp: IInterface;

otmp := TAccountDataExtend.Create;
otmp.FID:= i;
// aber tmp nicht zwischenzeitlich als Interface verwenden!!!
tmp := otemp;
// jetzt kann man das Interface verwenden
_o.Add( tmp );

oder besser doch so:

Delphi-Quellcode:

var tmp: IInterface;

tmp := TAccountDataExtend.Create(i);
_o.Add( tmp );

also entweder dein FID im Constructor mit übergeben
oder das FID auch im Interface verfügbar machen

Delphi-Quellcode:

IDataObject = interface( IInterface )
  ['{C94DCAC7-CA42-45D3-95D7-9BC321BA2E2A}']
  procedure Delete;
  property FID read ... write ...;  // bzw. nur eine SetFID-Prozedur
end;

var tmp: IInterface;

tmp := TAccountDataExtend.Create;
tmp.FID := i;  // tmp.SetFID(i);
_o.Add( tmp );

[RedOne]

Macht durchaus Sinn zuerst das Objekt zu erstellen und dann daraus ein Interface zu kreieren:

Delphi-Quellcode:

procedure GetAllAccounts( _o: TInterfaceList );
var
  tmp: TAccountDataExtend;
begin
  for i:= 0 to 4 do begin
    tmp:= TAccountDataExtend.Create;
    tmp.FID:= i;
    _o.Add( tmp );
    tmp._AddRef;
  end;
end {GetAllAccounts};

Sonst funktionierts nämlich nicht :-)
Die Referenzzählung brauche ich meiner Meinung nach weil ich die InterfaceList zerstöre. Ansonsten bringt er eine Exception bei beenden des OnClick-Events.
Er gibt mir jetzt in der Deletefunktion meinen gewünschten Wert aus.
Dafür... im Grid nicht mehr :-) Jetzt zeigt dieses immer "0" an.
Ich bekomme von der Funktion GetAllAccounts eine Interfacelist. Ich sollte diese doch gleich wie beim OnClick-Ereignis in ein TAccountDataExtend casten können?

Delphi-Quellcode:

var
  i: IDataObject;
  obj: IInterface;
  obj3: IDataObject;
  
begin
  obj:= IInterface( Pointer( ListViewMain.Selected.Data ));
  if Succeeded( obj.QueryInterface( IDataObject, obj3 )) then begin
    ShowMessage( TAccountDataExtend( obj3.XYZ ));
  end;
end;

Arbeite übrigens mit Delphi 2007

Vielen Dank

[RedOne]

Ich muss übrigens nicht zwingend diese Architektur verwenden. Wenn jemand eine schönere Lösung weiss, so bin ich gerne bereit alles umzubauen :-)
Ich möchte einfach vermeiden dass in der Formklasse zusätzlich zum Grid eine Objektliste gepflegt werden muss und somit die Daten eigentlich doppelt vorhanden sind.
Im Anhang ein bescheidener Versuch diesen Teil der Software UML-mässig abzubilden. Musste mich zuerst im Enterprise Architect zurecht finden... deshalb etwas stümperhaft :-)
Zu den beiden Formulare/Objekte Account und Action's gesellen sich noch einige mehr hinzu, deren Aufbau aber immer gleich ist.

Vielen Dank

[brechi]

Also ich hab das auch mit Delphi2007 getestet. Das AddRef brauchst du weil die InterfaceListe zerstört wird aber du immernoch über Data auf das Object zugreifen willst.

So gehts:

Delphi-Quellcode:

type
  IDataObject = interface(IInterface)
    ['{C94DCAC7-CA42-45D3-95D7-9BC321BA2E2A}']
    procedure Delete;
  end;

  IAccountData = interface(IInterface)['{DA626905-CB35-4474-B353-9F8E973709AA}']
    function GetId: Integer;
    procedure SetId(_Id: Integer);
    property ID: Integer read Getid write SetId;
  end;

  TAccountData = class(TInterfacedObject, IAccountData)
  protected
    FID: Integer;
    function Getid: Integer;
    procedure SetId(_Id: Integer);
  public
    destructor Destroy; override;
  end;

  TAccountDataExtend = class(TAccountData, IDataObject)
  public
    procedure Delete;
  end;

procedure TForm9.ListViewMainClick(Sender: TObject);
var
  obj: IInterface;
  obj3: IDataObject;
begin
  inherited;
  if ListViewMain.ItemIndex >= 0 then begin
    obj := IInterface(ListViewMain.Selected.Data);
    if Succeeded(obj.QueryInterface(IDataObject, obj3)) then begin
      obj3.Delete; //Funktion siehe unten
    end;
  end;
end;

procedure TForm9.ListViewMainDeletion(Sender: TObject; Item: TListItem);
begin
  IInterface(Item.Data)._Release;
end;

procedure TForm9.Refresh;
var
  tmp: IAccountData;
  i: Integer;
  item: TListItem;
  x: TInterfaceList;
begin
  //Vorgängig Listview aufräumen, Objekte zerstören, Interface Releasen

  x := TInterfaceList.Create;
  try
    GetAllAccounts(x); //Siehe Funktion unten
    for i := 0 to x.Count - 1 do begin
      if Succeeded(x[i].QueryInterface(IAccountData, tmp)) then begin
        item := ListViewMain.Items.Add;
        item.Caption := IntToStr(tmp.ID); //Zeigt korrekte ID an
        item.Data := Pointer(tmp);
      end;
    end;
  finally
    FreeAndNil(x); //Ich nehme an die InterfaceList zerstört die Objekte nicht
  end;
end {LoadListView};

procedure TForm9.Button1Click(Sender: TObject);
begin
  Refresh;
end;

procedure TForm9.GetAllAccounts(_o: TInterfaceList);
var
  tmp: IAccountData; //Oder IInterface?
  i: integer;
begin
  for i := 0 to 4 do begin
    tmp := TAccountDataExtend.Create;
    tmp.ID := i;
    tmp._AddRef;
    _o.Add(tmp);
  end;
end {GetAllAccounts};

//----------------- TAccountDataExtend

procedure TAccountDataExtend.Delete;
begin
  ShowMessage(IntToStr(FID));
end {Delete};

{ TAccountData }

destructor TAccountData.Destroy;
begin
  MessageBox(0,'del',nil,0);
  inherited;
end;

function TAccountData.Getid: Integer;
begin
  Result := Fid;
end;

procedure TAccountData.SetId(_Id: Integer);
begin
  Fid := _id;
end;

hab auch mal nen destructor eingebaut, damit du siehst wann das object zerstört wird (ohne _addref schon beim zerstören der InterfaceList). Und damit du kein Speicherleck hast musst du auch wieder _Release aufrufen.

Im grunde brignt das das nte viel bei dem Beispiel weil du ne Sonderbehandlung bei Data brauchst. Dann kannst auch auf interfaces verzichten und gleich selbst freigeben (es sei denn es wird ein externes Modul wo du mit interfaces drauf zugreifen willst).

[brechi]

Oder du schreibst dir deine eigene TListView die alles für dich übernimmt:

Delphi-Quellcode:

unit Unit9;

interface

uses
  Windows,
  Messages,
  SysUtils,
  Variants,
  Classes,
  Graphics,
  Controls,
  Forms,
  Dialogs,
  ComCtrls,
  StdCtrls;

type
  TListView = class(comCtrls.TListView)
  private
    FOnDeletion: TLVDeletedEvent;
    procedure SetOnDeletion(const Value: TLVDeletedEvent);
    function GetOnDeletion: TLVDeletedEvent;
  protected
    procedure InternOnDeletion(Sender: TObject; Item: TListItem);
  public
    constructor Create(AOwner: TComponent); override;
  published

    procedure AddItem(Item: String; AObject: IInterface); reintroduce;
    property OnDeletion: TLVDeletedEvent read GetOnDeletion write SetOnDeletion;
  end;

  TForm9 = class(TForm)
    ListViewMain: TListView;
    Button1: TButton;
    procedure ListViewMainClick(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
    procedure Refresh;
    procedure GetAllAccounts(_o: TInterfaceList);
  public
    { Public declarations }
  end;

var
  Form9: TForm9;

implementation

{$R *.dfm}

type
  IDataObject = interface(IInterface)
    ['{C94DCAC7-CA42-45D3-95D7-9BC321BA2E2A}']
    procedure Delete;
  end;

  IAccountData = interface(IInterface)['{DA626905-CB35-4474-B353-9F8E973709AA}']
    function GetId: Integer;
    procedure SetId(_Id: Integer);
    property ID: Integer read Getid write SetId;
  end;

  TAccountData = class(TInterfacedObject, IAccountData)
  protected
    FID: Integer;
    function Getid: Integer;
    procedure SetId(_Id: Integer);
  public
    destructor Destroy; override;
  end;

  TAccountDataExtend = class(TAccountData, IDataObject)
  public
    procedure Delete;
  end;

procedure TForm9.ListViewMainClick(Sender: TObject);
var
  obj: IInterface;
  obj3: IDataObject;
begin
  inherited;
  if ListViewMain.ItemIndex >= 0 then begin
    obj := IInterface(ListViewMain.Selected.Data);
    if Succeeded(obj.QueryInterface(IDataObject, obj3)) then begin
      obj3.Delete; //Funktion siehe unten
    end;
  end;
end;

procedure TForm9.Refresh;
var
  tmp: IAccountData;
  i: Integer;
  x: TInterfaceList;
begin
  //Vorgängig Listview aufräumen, Objekte zerstören, Interface Releasen

  x := TInterfaceList.Create;
  try
    GetAllAccounts(x); //Siehe Funktion unten
    for i := 0 to x.Count - 1 do begin
      if Succeeded(x[i].QueryInterface(IAccountData, tmp)) then begin
        ListViewMain.AddItem(IntToStr(tmp.ID), tmp);
      end;
    end;
  finally
    FreeAndNil(x); //Ich nehme an die InterfaceList zerstört die Objekte nicht
  end;
end {LoadListView};

procedure TForm9.Button1Click(Sender: TObject);
begin
  Refresh;
end;

procedure TForm9.GetAllAccounts(_o: TInterfaceList);
var
  tmp: IAccountData; //Oder IInterface?
  i: integer;
begin
  for i := 0 to 4 do begin
    tmp := TAccountDataExtend.Create;
    tmp.ID := i;
    _o.Add(tmp);
  end;
end {GetAllAccounts};

//----------------- TAccountDataExtend

procedure TAccountDataExtend.Delete;
begin
  ShowMessage(IntToStr(FID));
end {Delete};

{ TAccountData }

destructor TAccountData.Destroy;
begin
  MessageBox(0,'del',nil,0);
  inherited;
end;

function TAccountData.Getid: Integer;
begin
  Result := Fid;
end;

procedure TAccountData.SetId(_Id: Integer);
begin
  Fid := _id;
end;


{ TListView }

procedure TListView.AddItem(Item: String; AObject: IInterface);
begin
  AObject._AddRef;
  inherited AddItem(Item, Pointer(AObject))
end;

procedure TListView.SetOnDeletion(const Value: TLVDeletedEvent);
begin
  FOnDeletion := Value;
end;

constructor TListView.Create(AOwner: TComponent);
begin
  inherited;
  inherited OnDeletion := InternOnDeletion;
end;

function TListView.GetOnDeletion: TLVDeletedEvent;
begin
  Result := FOnDeletion;
end;

procedure TListView.InternOnDeletion(Sender: TObject; Item: TListItem);
begin
  if Assigned(item.Data) then
    IInterface(item.Data)._Release;
end;

end.

[himitsu]

In GetAllAccounts hat

Delphi-Quellcode:

tmp._AddRef;

nichts zu suchen, denn die Interfacelist arbeites ja korreckt und das Objekt wird da auch nie als Objekt verwendet.

Das Problem mit der Referenzzählung liegt an einer ganz anderen Stelle.
Und zwar bei

Delphi-Quellcode:

item.Data := Pointer(tmp);

, denn da wird eine Instanz des Interfaces gespeichert, aber ohne Berücksichtigung der Referenzzählung.
Nun gibt die InterfaceList natürlich beim

Delphi-Quellcode:

FreeAndNil(x)

ihre Referenzen frei und da es sonst keine registrierten RTeferenzen gibt, würden da die Interfaces/Objekte natürlich freigegeben.

Außerdem ist der Cast

Delphi-Quellcode:

IInterface(ListViewMain.Selected.Data);

falsch, denn in .Data steckt ein IAccountData und kein IInterfce.
Beide Interfaces (IAccountData und IInterfce) implementieren zum Glück das selbe QueryInterface, so daß es hier zufällig nicht zu einem Problem kommt.

Delphi-Quellcode:

type
  IDataObject = interface(IInterface)
    ['{C94DCAC7-CA42-45D3-95D7-9BC321BA2E2A}']
    procedure Delete;
  end;

  IAccountData = interface(IInterface)['{DA626905-CB35-4474-B353-9F8E973709AA}']
    function GetId: Integer;
    procedure SetId(_Id: Integer);
    property ID: Integer read Getid write SetId;
  end;

  TAccountData = class(TInterfacedObject, IAccountData)
  protected
    FID: Integer;
    function Getid: Integer;
    procedure SetId(_Id: Integer);
  public
    destructor Destroy; override;
  end;

  TAccountDataExtend = class(TAccountData, IDataObject)
  public
    procedure Delete;
  end;

procedure TForm9.ListViewMainClick(Sender: TObject);
var
  obj: IAccountData;  
  obj3: IDataObject;
begin
  //inherited; // himi: nicht nötig ... oder wurde hier was überschrieben?
  if ListViewMain.ItemIndex >= 0 then begin
    obj := IAccountData(ListViewMain.Selected.Data);
    if Succeeded(obj.QueryInterface(IDataObject, obj3)) then begin
      obj3.Delete; //Funktion siehe unten
    end;
  end;
end;

procedure TForm9.ListViewMainDeletion(Sender: TObject; Item: TListItem);
begin
  // himi: korreckt, nur daß hier nun nicht mehr die 
  // fehlerhafte Referenz von .GetAllAccounts freigegeben 
  // wird, sondern die aus .Refresh ;)
  IAccountData(Item.Data)._Release;
end;

procedure TForm9.Refresh;
var
  tmp: IAccountData;
  i: Integer;
  item: TListItem;
  x: TInterfaceList;
begin
  // Vorgängig Listview aufräumen, Objekte zerstören, Interface Releasen
  // himi: das sollte diese Zeile erledigen
  ListViewMain.Items.Clear; 

  x := TInterfaceList.Create;
  try
    GetAllAccounts(x); //Siehe Funktion unten
    for i := 0 to x.Count - 1 do begin
      if Succeeded(x[i].QueryInterface(IAccountData, tmp)) then begin
        item := ListViewMain.Items.Add;
        item.Caption := IntToStr(tmp.ID); //Zeigt korrekte ID an
        tmp._AddRef;  // himi: hier die Referenz für .Data reservieren
        item.Data := Pointer(tmp);
      end;
    end;
  finally
    FreeAndNil(x); 
    //Ich nehme an die InterfaceList zerstört die Objekte nicht
    // himi: doch, wenn sie die "einzige" Referenz der 
    // Interfaces besitzen würde
  end;
end {LoadListView};

procedure TForm9.Button1Click(Sender: TObject);
begin
  Refresh;
end;

procedure TForm9.GetAllAccounts(_o: TInterfaceList);
var
  tmp: IAccountData; //Oder IInterface?
    // himi: nee, denn sonst könnte man ja nicht auf .ID zugreifen
  i: integer;
begin
  for i := 0 to 4 do begin
    tmp := TAccountDataExtend.Create;
    tmp.ID := i;
    //tmp._AddRef;  // himi: wie gesagt ... ist falsch hier
    _o.Add(tmp);
  end;
end {GetAllAccounts};

//----------------- TAccountDataExtend

procedure TAccountDataExtend.Delete;
begin
  ShowMessage(IntToStr(FID));
end {Delete};

{ TAccountData }

destructor TAccountData.Destroy;
begin
  ShowMessage('del ' + IntToStr(FID));
  inherited;
end;

function TAccountData.GetId: Integer;
begin
  Result := FID;
end;

procedure TAccountData.SetId(Id: Integer);
begin
  FID := Id;
end;

[brechi]

Delphi-Quellcode:

tmp._AddRef; // himi: hier die Referenz für .Data reservieren
        item.Data := Pointer(tmp);

hier ist das Addref wirklich besser aufgehoben (in meinem 2. Post mach ich das direkt über das AddItem)

"Beide Interfaces (IAccountData und IInterfce) implementieren zum Glück das selbe QueryInterface, so daß es hier zufällig nicht zu einem Problem kommt."
Ne ist ja gerade kein Zufall da IAccountData = interface(IInterface).
Gut beim Casten kann man natürlich direkt richtig casten, aber man hat dann ggf. Probleme wenn man unterschiedliche Interfaces in die Liste eingefügt hat, dann ist ein IInterface.QueryInterface schon geeigneter, oder übersehe ich da jetzt was ganz dummes?

[himitsu]

Zitat:

Zitat von brechi (Beitrag 1035575)

Ne ist ja gerade kein Zufall da IAccountData = interface(IInterface).

OK, das mit den unterschiedlichen Interfaces in der Liste ist ein gutes Argument.

Aber wenn man danach dann wirklich nochmal das richtige Interface (z.B. via Supports) abfragt, dann isses OK.

Nur das Zufällig meinte ich etwas anders ... Wenn man jetzt z.B. etwas Spezielles von irgendeinem Interface (und nicht nur das überall bekannte Supports) nutzten/aufrufen wöllte, dann wäre es schon wichtig, daß man in den richtigen InterfaceType castet.

Also dann gebe ich mich in diesem Fall geschlagen. :angle2:

Zitat:

Zitat von brechi (Beitrag 1035575)

hier ist das Addref wirklich besser aufgehoben

Jupp, ist vorallem für den Fall, daß es zwischen ._AddRef und dem Zuweisen auf den Pointer eine Exception gibt (auch wenn sowas selten wäre und wohl nie vorkommt), aber in soeinem Fall würde, die via _AddRef reservierte Referenz, ja nicht angelegt/genutzt und das Interface würde dann nie freigegeben.
@brechi: ich denke mal du weißt es, aber falls sich mal wer nach dem Grund fragt.

[RedOne]

Hallo zusammen

Interessante Anmerkungen, merci.
Habe es soweit umgesetzt. Einziger Nachteil: Ich bin faul ;-)
Sehe ich es richtig dass es in Delphi 2007 keinen Weg gibt ein Interfaceobjekt, also mein Objekt im Data direkt in ein Objekt umzuwandeln, in TAccountData umzuwandeln? Ich rufe im OnClickereignis eine abstrakte Methode auf die im abgeleiteten Form implementiert wird. Dieser Methode gebe ich das markierte Objekt aus dem Data mit. Doch dieses sollte ich in mein TAccountData (oder TActionData, je nach dem welches Formular aufgerufen wurde) Objekt umwandeln da die Funktionen die ich brauche für jedes Objekt anders ist und daher nicht im IDataObject implementiert werden können.
Ansonsten muss ich für jede Klasse ein Interface erstellen und für sämtliche Attribute (ist ja nicht nur die ID) eine Get und Set-Methode zu schreiben (ein Property direkt auf die Variable ist im Interface nicht möglich).
Ich hoffe dieses kauderwelsch hat man verstanden :-)

Verständnisfrage: Beim abarbeiten meiner IInterfaceList schreibe ich das Objekt in das Data-Attribut. Jetzt wird doch der Pointer des Objektes dort eingetragen, oder? Von daher sollte ich doch auf das Objekt zugreifen könne, falls mir bekannt ist, um welche Klasse es sich handelt? Ich müsste also anhand des Datas einmal auf das Intergefacte Objekt (Deutsch für Anfänger...) im Basisform und einmal direkt auf das Objekt (im abgeleiteten Form) zugreifen können...

[Edit]
Ähm... nochmals eine blöde Frage: Wie zerstöre ich mein Objekt im Data beim Neuaufbau der Listview?

Delphi-Quellcode:

for i:= 0 to ListViewMain.Items.Count - 1 do begin
  if Assigned( TAccountData( ListViewMain.Items[ i ].Data )) then begin
    //#1
    IDataObject( ListViewMain.Items[ i ].Data ).Free; //klappt ja nicht, da Interface
    //#2
    TAccountData( ListViewMain.Items[ i ].Data ).Free; //Geht nicht: Um diesen Cast handelt sich dieser Thread eigentlich :-)
    //#3
    obj:= IInterface( Pointer( ListViewMain.Selected.Data ));
    if Succeeded( obj.QueryInterface( IDataObject, obj3 )) then begin
      obj3.Free;// klappt ja auch nicht da Interface...
    end;
  end;
end;

Herzlichen Dank
RedOne

[himitsu]

Zitat:

Zitat von RedOne (Beitrag 1035652)

Sehe ich es richtig dass es in Delphi 2007 keinen Weg gibt ein Interfaceobjekt, also mein Objekt im Data direkt in ein Objekt umzuwandeln, in TAccountData umzuwandeln?

jupp (fast)
http://www.delphipraxis.net/152892-v...ml#post1035377 (einige der Posts dieses Themas)

[RedOne]

Ok. Wenigstens einen Lichtblick in der Zukunft ;-)

Eine kurze Frage noch zum löschen. Ich habe es jetzt so gemacht dass im Interface eine Funktion existiert die sich selbst als Objekt zurück gibt.

Delphi-Quellcode:

  IDataObject = interface( IInterface )
    ['{C94DCAC7-CA42-45D3-95D7-9BC321BA2E2A}']
    function Load( _id: Integer ): Boolean;
    function Insert: Boolean;
    function Update: Boolean;
    procedure Delete;
    procedure SetSelfObject( _o: TObject );
    function GetSelfObject: TObject;
  end;

procedure TAccountData.SetSelfObject( _o: TObject );
begin
  FSelfObject:= TAccountDataExtend( _o ); //Cast unnötig
end {SetSelfObject};

function TAccountData.GetSelfObject: TObject;
begin
  Result:= FSelfObject;
end {GetSelfObject};

Aber wie lösche ich mein Objekt nun wieder?
Mittels xy.GetSelfObject.Free wird eine "unnötige Zeigeroperation" ausgelöst.
Ich habe testweise bei der Generierung der Listview meine Objekte noch in eine TObjectList gespeichert und diese durchgeloopt. Auch dies gibt eine "unnötige Zeigeroperation". Blockiert mich das Interface? Wie wäre der korrekte/schöne Weg diese Objekte zu löschen?

Herzlichen Dank

[himitsu]

Das Objekt hinter einem Interface löscht man nicht!

Wenn alle Referenzen auf das Objekt freigegeben sind (Variablen existieren nicht mehr oder wurden auf NIL, bzw. ein anderes Interface gesetzt), dann gibt sich das Interface selber frei,
also dann, wenn es keiner mehr braucht.

[edit]
ach menno, hier sinds ja 2 Objekte ... hmmm

"unnötige Zeigeroperation" ... meinst du vielleich "ungültige" ?

Wenn ja, dann ist der Zeiger falsch, bzw. zeigt nicht auf (d)ein Objekt.

[RedOne]

Ah cool. Eigentlich mag ich es nicht wenn mit jemand Arbeit abnimmt aber in diesem Fall... ;-)

Es ist doch nur ein Objekt. In "SelfObject" befindet sich nur eine weitere Referenz auf das Objekt.

Und ja, sollte natürlech "ungültige" heissen :-)