ObjectList im Zusammenspiel mit Interfaces

[angos]

Hallo zusammen,

ich traue mich momentan an das Thema Interfaces ran.

Ich möchte gerne Objekte innerhalb einer DLL erstellen und auf diese Objekte dann mittels Interfaces in der Hauptanwendung zugreifen. Soweit habe ich auch noch kein Problem, das klappt alles sauber.

Jetzt möchte ich eine Objektliste als interface bereitstellen, aber irgendwie komm ich an der Stelle auf keinen grünen Zweig. Wie gehe ich das nun an?

Ich habe schon viel gelesen und auch einige Tutorials gefunden, aber die befassen sich nur mit Nicht-Listen-Objekten und helfen mir entsprechend gar nicht weiter.

WICHTIG:
- Nach außen hin sollen die List-Items ebenfalls als Interace bereitgestellt werden.
- Ich möchte die Items über das Interface sowohl lesen, schreiben, hinzufügen als auch löschen können.

[EDIT] Ich möchte in der Hauptanwendung auch nur die units mit Interface-Deklarationen einbinden müssen und eben keine Units mit Objektdeklarationen.


Gruß
Ansgar

[ele]

Eventuell ist TInterfaceList was für dich.

Ich kapsle in der Regel das Interface in einem Objekt und hänge dieses an eine ganz normale TObjectList oder TStringList.

Delphi-Quellcode:

  
  TInterfaceWrapper = class
    FValue: IUnknown;
  public
    constructor Create(Int: IUnknown);
    destructor Destroy; override;
    property Value: IUnknown read FValue write FValue;
  end;

implementation

{ TInterfaceWrapper }

constructor TInterfaceWrapper.Create(Int: IInterface);
begin
  FValue := Int;
end;

destructor TInterfaceWrapper.Destroy;
begin
  FValue := nil;
  inherited;
end;

[angos]

Hi nochmals,

ich glaube das ist nicht ganz das was ich suche.
Ich bin in der Zwischenzeit hingegangen und habe mir in einem Testprojekt eben eine solche Liste exportiert... Nun funktioniert das bei mir. Da ich nciht weis, ob das vielleicht einfach mal zufällig funktioniert, und ich eigentlich doch noch einen Fehler mache hier einmal mein Testprojekt.

Habe das Projekt zusätzlich einmal angehangen, falls jemand nochmal direkt reinschauen muss/moechte.

Kann man das so machen, oder mache ich da noch etwas falsch? Vielen dank für alle Anregungen.

1. Die DLL zum erzeugen der Objekte/Zurückliefern des Interfaces:

DLL - DPR

Delphi-Quellcode:

library myobjects;

uses
  SysUtils,
  Classes,
  obj_myobject in 'obj_myobject.pas',
  obj_myobjectlist in 'obj_myobjectlist.pas',
  itf_myobjectlist in '..\Shared\itf_myobjectlist.pas',
  itf_myobject in '..\Shared\itf_myobject.pas';

{$R *.res}

function CreateMyObjectList: IMyObjectList;
begin
  Result := TMyObjectList.Create;
end;

function CreateMyObject: IMyObject;
begin
  Result := TMyObject.Create;
end;

exports
  CreateMyObjectList,
  CreateMyObject;

begin
end.

DLL-Unit für die Objektliste

Delphi-Quellcode:

unit obj_myobjectlist;

interface

uses
  itf_myobjectlist,
  itf_myobject,
  obj_myobject,
  Classes;

type
  TMyObjectList = class(TInterfaceList, IMyObjectList)
  private
    function GetItem(ANdx: Integer): IMyObject;
    procedure SetItem(ANdx: Integer; const AValue: IMyObject);

    function Summe: Integer;
  public
    property Items[ANdx: Integer]: IMyObject read GetItem write SetItem;
  end;

implementation

function TMyObjectList.GetItem(ANdx: Integer): IMyObject;
begin
  Result := IMyObject(inherited Items[ANdx]);
end;

procedure TMyObjectList.SetItem(ANdx: Integer; const AValue: IMyObject);
begin
  inherited Items[ANdx] := AValue;
end;

function TMyObjectList.Summe: Integer;
var
  i: Integer;
begin
  Result := 0;
  for i := 0 to Count - 1 do
  begin
    Inc(Result, Items[i].Value);
  end;
end;

end.

DLL-Unit für das Objekt

Delphi-Quellcode:

unit obj_myobject;

interface

uses
  itf_myobject;

type
  TMyObject = class(TInterfacedObject, IMyObject)
  private
    FValue: Integer;
    function GetValue: Integer;
    procedure SetValue(const AValue: Integer);
  public
    property Value: Integer read GetValue write SetValue;
  end;

implementation

{ TMyObject }

function TMyObject.GetValue: Integer;
begin
  Result := FValue;
end;

procedure TMyObject.SetValue(const AValue: Integer);
begin
  FValue := AValue;
end;

Und hier jetzt einmal die Exe

Main-Unit

Delphi-Quellcode:

unit main;

interface

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

type
  TForm1 = class(TForm)
    btn1: TButton;
    procedure btn1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.btn1Click(Sender: TObject);
var
  MyList: IMyObjectList;
  i: Integer;
begin
  MyList := CreateMyObjectList;
  for i := 0 to 9 do
  begin
    MyList.Add(CreateMyObject);
    MyList.Items[i].Value := i * 2;
  end;

  ShowMessage(IntToStr(MyList.Summe));
end;

end.

Unit mit den Funktionsaufrufen zur DLL

Delphi-Quellcode:

unit u_interface_functions;

interface

uses
  itf_myobjectlist,
  itf_myobject;

function CreateMyObjectList: IMyObjectList; external 'myobjects.dll';
function CreateMyObject: IMyObject; external 'myobjects.dll';

implementation

end.

Und zum Schluss die von beiden benutzten Interfaces

Interface für die Objektliste

Delphi-Quellcode:

unit itf_myobjectlist;

interface

uses
  itf_myobject;

type
  IMyObjectList = interface
    ['{745DFF06-A671-42FE-B3DE-B6BBCBDEB154}']

    function GetItem(ANdx: Integer): IMyObject;
    procedure SetItem(ANdx: Integer; const AValue: IMyObject);
    function Summe: Integer;
    function Add(const Item: IInterface): Integer;

    property Items[ANdx: Integer]: IMyObject read GetItem write SetItem;
  end;

implementation
end.

Interface für das Objekt

Delphi-Quellcode:

unit itf_myobject;

interface

type
  IMyObject = interface
    ['{B95AF2E0-16AD-4CA6-8296-6457788DA213}']

    function GetValue: Integer;
    procedure SetValue(const AValue: Integer);

    property Value: Integer read GetValue write SetValue;
  end;

implementation
end.

Gruß
Ansgar