Delphi-PRAXiS - Delphi Interfaces / Pseudo-Plugin

Hallo zusammen, ihr Helden meiner schlaflosen Nächte :shock:

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 :freak:

[edith]