Interfaces / Pseudo-Plugin - wie geht's richtig?

[silver-moon-2000]

Hallo zusammen, ihr Helden meiner schlaflosen Nächte

ich habe wieder mal ein Problem, das bei einem Großteil von Euch Kopfschütteln hervorrufen dürfte.
Es handelt sich dabei um eine sehr längliche Frage zum Grundsatzthema Interfaces.



Ich habe ein Hauptprogramm, das eine sogenannte Queue ("array of RBlubb" mit RBlubb=Record) verarbeitet. Im Endeffekt sind das Anweisungen zur sequentiellen Steuerung einer Relaiskarte.

Diese Queue soll dabei von einer Reihe von "Plugins" erstellt werden. Jedes Plugin besteht dabei aus einer Form mit mehreren visuellen Komponenten und eben einem Button, die diese erstellte Queue an das Hauptprogramm senden soll.

Das Plugin muss jedoch vom Hauptprogramm eine Rückmeldung erhalten, wie "gut" die erstellte Queue ist, damit sie gegebenenfalls überarbeitet werden kann.


So habe ich es bisher umgesetzt

Im Hauptprogramm:

Delphi-Quellcode:

 type IPluginInterface = interface(IInterface)
  ['{2E9D5924-ECB9-4068-8969-83AF8A604A66}']
  procedure receiveQueue(q : TQueue);
  function sendEvaluation(q: TQueue) : Single;
  function isQueueRunning: Boolean;
end;

Delphi-Quellcode:

type TMainInterface = class(TInterfacedObject, IPtO)
  public
    procedure recieveQueue(q : TQueue);
    function sendPoints(q: TQueue) : Single;
end;

procedure TMainInterface.recieveQueue(q : TQueue);
begin
  //hier wird Queue gespeichert und zum Weiterverarbeiten aufbereitet
end;

function TMainInterface.send Evaluation(q : TQueue) : Single;
begin
  //hier wird Queue grob ausgewertet und ein Qualitätsfaktor ermittelt
end;

function TMainInterface.IsQueueRunning : Boolean;
begin
  //wenn Queue abgearbeitet wird, darf Plugin Queue nicht übertragen
end;

im Plugin:

Delphi-Quellcode:

type TPlugin = class(TObject)
  private
    FQueue : TQueueSequence;
    FPointEst : Single;
  public
    procedure CreateQueue;
    procedure getQualityFactor;
    procedure SendQueue;
end;

procedure TPlugin.getQualityFactor;
var inter : IPluginInterface;
begin
  inter := TMainInterface.Create;
  FPointEst := inter.sendEvaluation(FQueue);
  inter := nil;
end;

procedure TPlugin.SendQueue;
var inter : IPluginInterface;
begin
  inter := TMainInterface.Create;
  if not inter.isQueueRunning then
    inter.recieveQueue(FQueue);
  inter := nil;
end;

procedure TPlugin.CreateQueue;
begin
  //hier wird die Queue erstellt
end;

Nach dieser langen Einführung jetzt meine Frage:
Habe ich das Prinzip des Interfaces überhaupt richtig verstanden? Damit meine ich: ist es nicht im Allgemeinen das Plugin, das das Interface implementiert?

So stelle ich mir den richtigen Umgang mit Interfaces vor

Delphi-Quellcode:

type IPtM = interface(IInterface)
  ['{2E9D5924-ECB9-4068-8969-83AF8A604A66}']
  function provideQueue : string;
  procedure getPoints(p : Integer);
end;

type TProgram = class(TObject)
  private
    FQueue : string;
  public
    procedure getQueue;
    function providePointEst : Integer;
end;

type TPlugin = class(TInterfacedObject, IPtM)
  private
    FQueue : string;
    FPointEst : Integer;
  public
    procedure CreateIndividualQueue;

    function provideQueue : string;
    procedure getPoints(p : Integer);
end;

implementation

procedure TProgram.getQueue;
var inter : IPtM;
begin
  inter := TPlugin.create;
  FQueue := inter.provideQueue;
  inter := nil;
end;

function TProgram.providePointEst: Integer;
var inter : IPtM;
begin
  inter := TPlugin.create;
  inter.getPoints(providePointEst(inter.provideQueue));
  inter := nil;
end;

{ TProgram }

procedure TPlugin.CreateIndividualQueue;
begin
  FQueue := 'abc';
end;

procedure TPlugin.getPoints(p: Integer);
begin
  FPointEst := p;
end;

function TPlugin.provideQueue: string;
begin
  Result := FQueue;
end;

In diesem Fall habe ich aus dem Plugin aber keine Möglichkeit, die Queue an das Programm zu schicken, sondern das Programm "fordert" die Queue beim PlugIn an?
Der "send Queue" Button des PlugIns "wandert" dann also zum Programm und heißt jetzt "get Queue", oder irre ich mich?

Die Frage kurz zusammengefasst:
- Wenn das Plugin das Interface implementiert, geht dem PlugIn die Rolle des Aktiven verloren (er kann nicht mehr selbst senden), sondern es kann nur noch auf Anfrage des Hauptprogramms die Queue bereitstellen?

- Wie geht's also richtig? Wer muss das Interface implementieren?

Tut mir wirklich leid, keine besser formulierte Frage stellen zu können, aber ich verweise dabei auf meine Signatur

[edith]

[xaromz]

Hallo,

Zitat von silver-moon-2000:

- Wenn das Plugin das Interface implementiert, geht dem PlugIn die Rolle des Aktiven verloren (er kann nicht mehr selbst senden), sondern es kann nur noch auf Anfrage des Hauptprogramms die Queue bereitstellen?

nö, das geht schon immer noch. Du musst nur eine Möglichkeit einbauen, dass das Interface dem Hauptprogramm eine Nachricht zukommen lassen kann. Dazu gibt es viele Möglichkeiten (COM event sink, TNotifyEvent, Windows Message...)

Zitat von silver-moon-2000:

- Wie geht's also richtig? Wer muss das Interface implementieren?

Normalerweise implementiert das Plugin das Interface. Ist ja auch logisch: Das Hauptprogramm weiß durch das Interface, wie es beliebige Plugins ansprechen muss.

Gruß
xaromz

[RWarnecke]

Hallo Tobias,

schaue Dir mal das Plugin-Tutorial von sakura an. Damit habe ich erst richtig verstanden, wie Interfaces in Delphi richtig eingesetzt werden.

[silver-moon-2000]

Sorry, dass ich erst jetzt Zeit zum Antworten finde.

Zitat von RWarnecke:

Hallo Tobias,

schaue Dir mal das Plugin-Tutorial von sakura an. Damit habe ich erst richtig verstanden, wie Interfaces in Delphi richtig eingesetzt werden.

Danke für den Link, muss ich übersehen haben. Werde ich mir zu Gemüte führen.

Zitat von xaromx:

nö, das geht schon immer noch. Du musst nur eine Möglichkeit einbauen, dass das Interface dem Hauptprogramm eine Nachricht zukommen lassen kann. Dazu gibt es viele Möglichkeiten (COM event sink, TNotifyEvent, Windows Message...)

Ah, danke, das wird mir weiterhelfen, denke ich.

Ich werde mal weiterbasteln und bei Gelegenheit wieder dumm fragen