Arbeit mit Interfaces

[Lemmy]

Servus,

nehmen wir an ich will für das einbinden von DLLs ein kleines Plugin-System machen.

Delphi-Quellcode:

type
  IPlugin = Interface
  []
    procedure Init;
    procedure finalize;
   ....
  end;

  IFoo = interface
  []
    procedure DoSomething;
  end;

die DLL exportiert

Delphi-Quellcode:

  function GetPlugin: IPlugin
  begin
    result := ....
  end;

IPlugin soll dabei als allgemeines Interface dienen um so Dinge wie evtl. notwendige DB-Zugriff zu initialisieren bzw. allgemeine Initialisierung und Freigaben in der DLL zu kapseln. IFoo ist die eigentliche "Funktion" der DLL. Kann ich diese einfach "Huckepack" übergeben:

DLL:

Delphi-Quellcode:

 
type
  TFoo = class(TInterfacedObject, IPlugin, IFoo)
  .... 
  end;

und dann in der Anwendung:

Delphi-Quellcode:

Type
  TFoo = function: IPlugin;


var 
  bar: TFoo;
  plugin: IPlugin;
  Foo: IFoo;
begin
  bar := GetProcAdress(Handle, 'GetPlugin');
  if Assigned(bar) then
  begin
    plugin := bar();
    plugin.init;
    plugin.QueryInterface(IFoo, Foo);
    
    Foo.DoSomething; 
  
  end;
end;

Sprich: Darf ich hier lieb nachfragen, ob mein benötigtes Interface von der DLL implementiert wird um dann damit weiter zu arbeiten oder spricht irgend etwas dagegen?

[Schokohase]

Lieb nachfragen geht aber anders. So würde es knallen, wenn du keine IFoo Referenz bekommst.

Entweder vorher auf nil prüfen oder mit Supports und die Boolean Rückgabe auswerten.

[Lemmy]

Zitat von Schokohase:

Lieb nachfragen geht aber anders. So würde es knallen, wenn du keine IFoo Referenz bekommst.

Entweder vorher auf nil prüfen oder mit Supports und die Boolean Rückgabe auswerten.

sorry, das habe ich einfach unterschlagen - Rückgabewert von QueryINterface würde ich im Echtfall natürlich abprüfen

[jaenicke]

Ja, das geht so. Wir sind dabei aber einen Schritt weiter gegangen und haben Wrapper gebaut. So gibt es in der DLL und in der Anwendung jeweils eine Klasse, die Interfaces mit beliebigen Parametern gegenseitig, aber auch innerhalb der DLL oder Anwendung abrufen kann.

Dafür gibt es eine Registrierungsroutine in der DLL, die in einer separaten Unit steht. Es reicht daher diese Unit in die DLL einzubinden. Dann findet die Hostanwendung diese exportierte Funktion und übergibt an diese das Host-Interface. Darüber wird dann auch ein Client-Interface der DLL übergeben.

Und nun kann man darüber generisch nach einem bestimmten Interface-Typ fragen und Parameter mitgeben. Die Plugin-Klasse holt sich aus dem generischen Typ die GUID und fragt mit dieser GUID über das Interface die Hostanwendung nach einer passenden Instanz usw.

Beispiel:

Delphi-Quellcode:

IntParam := TParam<Integer>.Create(42);
IntfRef := TApp.Get<ITestPlugin>(IntParam);