Plugin-System

[paule32.jk]

Hallo,

ich würde gerne ein Plugin-System einführen, so dass der Benutzer entscheiden kann,
was er in sein Programm lädt ...
Ich habe dazu vor, einen Manager zu basteln, der folgenden Code enthält:

Delphi-Quellcode:

unit pluginManager;

interface

uses
  Windows, Classes, SysUtils, Forms, Dialogs,
  plugin;

type
  TkPlugInManager = class(TComponent)
  private
    FPlugins: TList;
  protected
    function GetPlugins: FPlugins;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    procedure LoadPlugin(FileName: String); virtual;
    procedure UnLoadPlugin(index: Integer); virtual;

    procedure GetLoadedPlugins(PluginList: TStrings); virtual;

    property PlugIns[index: Integer] : TkPlugin read GetPlugins; default
    property PlugInCount: Integer read GetPluginCount;

  published
    property Version: String read GetVersion write SetVersion;
  end;

implementation

constructor TkPlugInManager.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
end;

destructor TkPlugInManager.Destroy;
begin
  inherited Destroy;
end;

end.

Für die Plugin-Struktur würde ich folgende verwenden:

Delphi-Quellcode:

unit plugin;

interface

uses
  Windows, Classes, SysUtils, Forms, Dialogs;

type
  TkPlugin = class(TObject)
  private
    FHostApplication: TApplication;
    FFileName       : String;
    FFileAuthor     : String;
    FFileDescription: String;
    FManager        : TComponent;
  public
    constructor Create;
    destructor Destroy; override;

    function GetName: String; virtual; stdcall;
    function GetAuthor: String; virtual; stdcall;
    function GetDescription: String; virtual; stdcall;

    function GetNumCommands: Integer; virtual; stdcall;

    property HostApplication: TApplication read FHostApplication;
    property FileName: String read FFileName;
    property Manager: TComponent read FManager;
  end;

implementation

constructor TkPlugin.Create;
begin
end;

destructor TkPlugin.Destroy;
begin
end;

function TkPlugin.GetName: String;
var
  TheFileName : array[0..MAX_PATH] of char;
begin
  FillChar(TheFileName, sizeof(TheFileName), #0);
  GetModuleFileName(hInstance, TheFileName, sizeof(TheFileName));
  result := TheFileName;
end;

function TkPlugin.GetAuthor: String;
begin
  result := FFileAuthor;
end;

function TkPlugin.GetDescription: String;
begin
  result := FFileDescription;
end;

function TkPlugin.GetNumCommands: Integer;
begin
  result := 0;
end;

end.

in der Zeile: 14 bekomme ich einen Fehler: "Undeclared identifier: 'FPlugins'."
könnt Ihr mich helfen, ein kleines Plugin-System zu basteln ?

Danke schonmal für sachdienliche Hinweise

paule32

[mmw]

Hallo,

so sollte es funktionieren

Delphi-Quellcode:

type
  TkPlugInManager = class(TComponent)
  private
    FPlugins:TkPlugin;
    FVersion:String;
  protected
    function GetPlugins(indx:Integer): TkPlugin;
    procedure LoadPlugin(FileName: String); virtual;
    procedure UnLoadPlugin(index: Integer); virtual;

    function  Getversion:string;
    procedure Setversion(value:String);

    function GetLoadedPlugins:TStrings; virtual;
    function GetPluginCount:Integer;

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property PlugIns [index: Integer]: TkPlugin read GetPlugins;
    property PlugInCount: Integer read GetPluginCount;

  published
    property Version: String read GetVersion write SetVersion;
  end;

Gruß

[paule32.jk]

Hallo @mmw,
Danke für Deine Tipps !

Ich habe dann mal ein wenig weiter gebastelt...
- die Datei: plugin.pas:

Delphi-Quellcode:

unit plugin;

interface

uses
  Windows, Classes, SysUtils, Forms, Dialogs;

type
  TkPlugin = class(TObject)
  private
    FHostApplication: TApplication;
    FFileVersion    : String;
    FFileName       : String;
    FFileAuthor     : String;
    FFileDescription: String;
    FManager        : TComponent;
  public
    constructor Create;
    destructor Destroy; override;

    function GetNumCommands: Integer; virtual; stdcall;

    function GetVersion: String; virtual; stdcall;
    function GetName: String; virtual; stdcall;
    function GetAuthor: String; virtual; stdcall;
    function GetDescription: String; virtual; stdcall;

    procedure SetVersion(AString: String);

    property HostApplication: TApplication read FHostApplication;
    property FileName: String read FFileName;
    property Version: String read FFileVersion;
    property Manager: TComponent read FManager;
  end;

implementation

constructor TkPlugin.Create;
begin
end;

destructor TkPlugin.Destroy;
begin
end;

function TkPlugin.GetVersion: String;
begin
  result := FFileVersion;
end;

function TkPlugin.GetName: String;
var
  TheFileName : array[0..MAX_PATH] of char;
begin
  FillChar(TheFileName, sizeof(TheFileName), #0);
  GetModuleFileName(hInstance, TheFileName, sizeof(TheFileName));
  result := TheFileName;
end;

function TkPlugin.GetAuthor: String;
begin
  result := FFileAuthor;
end;

function TkPlugin.GetDescription: String;
begin
  result := FFileDescription;
end;

function TkPlugin.GetNumCommands: Integer;
begin
  result := 0;
end;

procedure TkPlugin.SetVersion(AString: String);
begin
  FFileVersion := AString;
end;

end.

- die Datei: pluginManager.pas

Delphi-Quellcode:

unit pluginManager;

interface

uses
  Windows, Classes, SysUtils, Forms, Dialogs,
  plugin;

type
  TkPlugInManager = class(TComponent)
  private
    FPlugins: TStrings;
    function GetPlugin(index: Integer): TkPlugin;
    function GetPluginCount: Integer;
    function GetVersion: String;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    function LoadPlugin(FileName: String): Boolean; virtual;

    function UnLoadPlugin(FileName: String): Boolean; overload; virtual;
    function UnLoadPlugin(index: Integer): Boolean; overload; virtual;

    property Items[index: Integer] : TkPlugin read GetPlugin; default;
    property Count: Integer read GetPluginCount;

  published
    property Version: String read GetVersion;
  end;

implementation

constructor TkPlugInManager.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
end;

destructor TkPlugInManager.Destroy;
begin
  inherited Destroy;
end;

function TkPlugInManager.GetPlugin(index: Integer): TkPlugin;
begin
  result := Items[index];
end;

function TkPlugInManager.GetPluginCount: Integer;
begin
  result := FPlugins.Count;
end;

function TkPluginManager.GetVersion: String;
begin
end;

function TkPluginManager.LoadPlugin(FileName: String): Boolean;
begin
  result := true;
end;

function TkPlugInManager.UnLoadPlugin(FileName: String): Boolean;
begin
  result := true;
end;

function TkPluginManager.UnLoadPlugin(index: Integer): Boolean;
begin
  result := true;
end;

end.

ich teste gerade, ob man den Code als BPL oder als DLL auslagern kann/muss ...

[jaenicke]

Deine Plugins könntest du dann, wenn du Delphi-Objekte zwischen Plugins und Hostanwendung verwenden möchtest, nur als Package umsetzen. Das ist allerdings nicht gerade schnell, wenig flexibel und nicht kompatibel mit anderen Delphiversionen und schon gar nicht anderen Sprachen und Plattformen. So etwas habe ich in meiner Anfangszeit mal angefangen und bin ganz schnell wieder davon abgekommen.

Interfaces und einfache DLLs gibt es auch in anderen Sprachen, zudem sind sie nicht z.B. von einer bestimmten Delphiversion abhängig. Deshalb würde ich diese immer vorziehen.

Dafür gibt es von mir ein Projekt, mit dem du ganz einfach Interfaces zwischen einer Delphi-Anwendung und (als Plugins) Delphi-DLLs und C#-DLLs austauschen kannst. C# als Hostanwendung und weitere Plattformen möchte ich auch noch hinzufügen.
https://www.delphipraxis.net/213199-...ng-dlls-c.html

[paule32.jk]

Danke @jaenicke,
ich habe auf Deine verlinkte Site einen Abstecher gemacht.
Allerdings ist der dort auffindbare Quelltext für höhere Versionen von Delphi;
aber durchaus interessant !

Da ich aber im Moment nur Delphi 7 nutzen möchte, ist der Code natürlich nicht
so ohne weiteres verwendbar.
Was natürlich den Lernerfolg nicht abträglich ist.

Der laufende Prozess der Entwicklung meines Plugin-Systems kann auch unter meinen
git Account eingesehen werden.

Mit freundlichen Grüßen
paule32

[jaenicke]

Zitat von paule32.jk:

Da ich aber im Moment nur Delphi 7 nutzen möchte, ist der Code natürlich nicht
so ohne weiteres verwendbar.

Früher war Delphi 7 ja auch sehr beliebt, auch mit nicht legalen Kopien, insbesondere in den Folgejahren. Da es die aktuelle Version heute für nicht-kommerzielle Nutzung kostenlos gibt, gibt es aber nur noch viel weniger Nutzer, so dass ich meine Open Source Projekte nicht mehr abwärtskompatibel halte.

Das Prinzip funktioniert aber auch mit Delphi 7 problemlos, nur dass man ohne Generics das Casten auf den konkreten Interfacetyp selbst außerhalb machen muss.

[himitsu]

Jupp, bei Packages geht nur die selbe Delphi-Version und womöglich auch noch die gleiche Update-/Patch-Version.

Als DLL mit Laufzeitpackages praktisch das Selbe.

DLL ohne Packages, aber mit Shared Memory -> in einem gewissen Bereich geht es mit mehreren/vielen Delphi-Versionen (so lange das SharedMemory auf beiden Seiten kompatibel ist)
Aber natürtlich sollte man hier auch keine Klassen/Objekte benutzen. (alles nur virtuelle Methoden, wäre grade so noch möglich)

DLL ohne alles, möglichst noch mit cdecl oder stdcall, und als String nur der WideString, schon ist es nahezu egal, was die andere Seite nutzt.
WideString ist eine Kapselung von SysStringLen und seinen Freunden, was auch andere Sprachen verstehen können.