PlugIns System mit Formularen

[TheMiller]

Hallo Jungs und Mädels,

ich habe schon 2, 3 Programme mit einem PlugIn-System erstellt. Habe mich dabei an das Tutorial aus diesem Forum gehalten (war es von Sharky..?).

Nun brauche ich bei meinen PlugIns Formulare. Die Frage, die ich mir nun stelle ist, ob es sinnvoll ist, DLLs als PlugIns zu benutzen, welche Formulare enthalten. Ich rede hier nicht von Dateigröße VCL etc und auch nicht über die Diskussion ob DLLs oder Packages.

Mir geht es darum, dass ich durch das Laden von Dlls mit Formularen und teilweise auch gleichen Komponenten auf Hauptanwwendung und DLL-Anwendung (ZEOS), öfter Probleme mit Speicherlecks habe. Dabei erstelle ich das Form sauber und beim Schließen des PlugIns oder Programms gebe ich dir Forms auch wieder frei. Trotzdem kommen AVs, Speicherlecks etc zum Vorschein.

Diese Fehler sind immer sehr mysteriös. Neuerdings ist es ja so (siehe meine anderen Threads), dass keine AV kommt, wenn das Hauptprogramm mit der DB verbunden ist. Ist es das nicht, treten "zu viele Exceptions" auf, wenn ich die DLL schließe.
Damals hatte ich das gleiche Problem mit einem TMedia-Player. Habe ich was aufgenommen, konnte ich beim Beenden des Programms eine riesen Latte speicherlecks beobachten, die mit dem MediaPlayer nix zu tun hatten.

Wie auch immer - es stört sich immer irgendwas.

Meine Frage nun: Hat jemand eine Idee / Link / etc für ein anderes PlugIn-System, ein Tutorial, oder ist das System eigentlich ok (DLLs dynamisch laden und entladen)?

Vielen Dank im Voraus

[SirThornberry]

Forms in DLL stellen keine Probleme dar. Wenn du dabei AVs bekommst machst du irgendwo was falsch - eventuell keine Berücksichtigung der verschiedenen Speichermanger? Oder keine Berücksichtigung das die Klassen in DLL und Hauptanwendung verschieden sind?

[TheMiller]

Ich weis es nicht. Immer beim Beenden kommen Speicherlecks zum Vorschein. Irgendwo steckt der Wurm drin.


Wenn du sagst, dass DLL-Forms ok sind, dann beginne ich nochmal von vorne. Da die Fehler beim Entladen auftreten, möchte ich nochmal kurz zeigen, wie ich die DLL-Forms lade und entlade. Vielleicht mache ich schon was falsch...

DLL.dpr

Delphi-Quellcode:

//Form erstellen
procedure TCalendar.InitPlugIn;
begin
  Form1:=TForm1.Create(nil);
end;

//Form anzeigen, wenn gewünscht
procedure TCalendar.Execute();
begin
  Form1.Show;
  //Form1.StartUp;
end;

//Form entladen
procedure TCalendar.FreeForms;
begin
  FreeAndNil(Form1);
end;

function LadePlugIn(Parent: THandle; var PlugIn: TProJurisPlugIn): Boolean;
begin
  try
    PlugIn := TCalendar.Create(Parent);
    Result := True;
  except
    Result := False;
  end;
end;

exports
  LadePlugIn;

das PlugIn wird bei Programmstart geladen und erstmal wieder entladen. Der Sinn ist, dass das Hauptprogramm sieht, welches PlugIn installiert ist und macht Menüeinträge. Wenn der User auf den Menüeintrag klickt, dann wird das PlugIn wieder mit LoadLibrary geladen. Beim Beenden des PlugIns wird es mit "FreeForms" entladen.

Ist doch generell richtig und sauber, oder?

[mkinzler]

Wo entlädst du?

[TheMiller]

Vom Hauptprogramm aus. In OnCloseQuery oder über einen Butten rufe ich

Delphi-Quellcode:

PlugIns[i].PlugInName.FreeForms

auf.

Und ich habe eben alles neu gemacht, und es ging... BIS: Ich wieder Zeos im PlugIn benutzt habe. Kann es sein, dass die neue Version einfach unsauber programmiert ist? Habe ich die Zeos draußen, geht alles perfekt. Zum Verständnis: Die Hauptanwendung initiiert eine Zeos-Connection über ihre eigene Zeos-Komponente. Die PlugIns haben auch jeweils alle eine eigen Zeos-Kompo, damit auch die auf die DB zugreifen können.

Danke

[mkinzler]

Du exportierst diese Funktion aber nicht

[TheMiller]

Nein, ich habe aber eine Schnittstelle dafür, über die ich darauf zugreife. Die einzige Funktion, die exportiert wird ist "LadePlugIn".

Hier mal die Schnittstelle, von der die PlugIns abgeleitet sind:

Delphi-Quellcode:

unit PJV3PlugIn;

interface

type
  TProJurisPlugIn = class
  private
    FParent: THandle;
    procedure SetParent(const Value: THandle);
  public
    constructor Create(aParent: THandle);

    //Laden, öffnen, schließen
    procedure CreateForms; virtual; stdcall; abstract;
    procedure Execute; virtual; stdcall; abstract;
    procedure FreeForms; virtual; stdcall; abstract;

    //Plug-In-Infos
    function GetTitel(Buffer: PChar; lenBuffer: Integer): Integer; virtual; stdcall; abstract;
    function GetAppKey(Buffer: PChar; lenBuffer: Integer): Integer; virtual; stdcall; abstract;

    function SendFormHandle: Integer; virtual; stdcall; abstract;
    //procedure SwitchShowStyle; virtual; stdcall; abstract;

    property Parent: THandle read FParent write SetParent;
  end;

  TLadePlugIn = function(Parent: THandle; var PlugIn: TProJurisPlugIn): Boolean;

implementation

constructor TProJurisPlugIn.Create(aParent: THandle);
begin
  inherited Create;
  FParent := aParent;
end;

procedure TProJurisPlugIn.SetParent(const Value: THandle);
begin
  FParent := Value;
end;

end.

und hier nochmal das PlugIn, welches diese Maske "füllt":

Delphi-Quellcode:

library Kalender;

uses
  FastMM4,
  Forms,
  SysUtils,
  PJV3PlugIn,
  Unit1 in 'Unit1.pas' {Form1};

type
  TCalendar = class(TProJurisPlugIn)
  public
    //laden, öffnen, schließen
    procedure CreateForms; override; stdcall;
    procedure Execute; override; stdcall;
    procedure FreeForms; override; stdcall;

    //Plug-In-Info
    function GetTitel(Buffer: PChar; lenBuffer: Integer): Integer; override; stdcall;
    function GetAppKey(Buffer: PChar; lenBuffer: Integer): Integer; override; stdcall;

    function SendFormHandle: Integer; override; stdcall;

    //procedure SwitchShowStyle; override; stdcall;
  end;

{$R *.res}

procedure TCalendar.CreateForms;
begin
  Form1:=TForm1.Create(nil);
end;

procedure TCalendar.Execute();
begin
  Form1.Show;
end;

procedure TCalendar.FreeForms;
begin
  FreeAndNil(Form1);
end;

function TCalendar.SendFormHandle: Integer;
begin
  result:=Form1.Handle;
end;

function TCalendar.GetTitel(Buffer: PChar; lenBuffer: Integer): Integer;
var
  s: String;
begin
  s:='Kalender';
  if (Assigned(Buffer)) then
  begin
    StrLCopy(Buffer, PChar(s), lenBuffer);
  end;
  result:=length(s);
end;

function TCalendar.GetAppKey(Buffer: PChar; lenBuffer: Integer): Integer;
var
  s: String;
begin
  s:='PJ-3';
  if (Assigned(Buffer)) then
  begin
    StrLCopy(Buffer, PChar(s), lenBuffer);
  end;
  result:=length(s);
end;

function LadePlugIn(Parent: THandle; var PlugIn: TProJurisPlugIn): Boolean;
begin
  try
    PlugIn := TCalendar.Create(Parent);
    Result := True;
  except
    Result := False;
  end;
end;

exports
  LadePlugIn;

begin
end.

[seim]

Wie kann man DLLs dymanisch entladen oder laden? Gib mir doch mal bitte den Link zu diesem Tutorial (falls du hier noch aktiv bist ^.^)

[omata]

Schau dir doch einfach mal LoadLibrary und FreeLibrary an.

klick