1:
2:
3:
4:

function Init: boolean; stdcall;
function GetName(var name: string) : Boolean; stdcall;
function GetIcon(var icon: TIcon) : Boolean; stdcall;
function OnCall(event: Integer): Boolean; stdcall;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

Procedure DLLAufruf(Dateiname, Funktionsname : String);
 VAR Plugin    : TPlugin1;
     FunctPtr  : TFarProc;
     DLLHandle : THandle;

  Begin
   DLLHandle := LoadLibrary(PChar(Dateiname));
   FunctPtr  := GetProcAddress(DLLHandle, PChar(Funktionsname));
   if FunctPtr <> nil then
    Begin
     @Plugin := FunctPtr;
     Plugin; //Aufruf der DLL-Funktion. Mit Übergabe der Parameter
     FunctPtr := nil;
    End
     Else
       Showmessage('Plugin nicht gefunden!');
       FreeLibrary(DLLHandle);
 End;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:

// Speichert alle Pfade zu Dlls, die gleichzeitig PlugIns sind
// Path ist der Pfad wo sich die Plugins befinden müssen
procedure GetPlugInNames(path: String; const items : TStringList);
var
   sr : TSearchRec;
begin
   path := IncludeTrailingBackslash(path)
   if FindFirst(path + '*.dll', faAnyFile, sr) = 0 then begin
      repeat
         if IsPlugIn(path + sr.Name) then
            items.Add(path +sr.Name);
      until FindNext(sr) <> 0;
      FindClose(sr);
    end;
end;

// Prüft ob es sich bei der Dll um ein PlugIn handelt
function IsPlugIn(path: String): Boolean;
var
   h : HMODULE;
   name: TGetNameFunc; 
   evt : TOnCallFunc; 
begin
   Result := false;
   h := LoadLibrary(PChar(path));
   if h = nil then exit;
   name := TGetNameFunc(GetProcAddress(h, 'GetName'));
   if name = nil then exit;
   evt := TOnCallFunc(GetProcAdress(h, 'OnCall'));
   if evt = nil then exit;
   
   Result := true;
end;

// Klasse des Fensters das die PlugIns verwaltet
TForm1 = class(TForm)
...
private
   // Hier ein statisches Array, dass die PlugIns verwaltet.
   plugIns_ : array[0..1024] of HMODULE;
   count_ : Integer; // Anzahl der PlugIns.
   // Ereignisbehandlung für die Menüs, der PlugIns
   class procedure OnPlugInMenuClick(sender : TObject);
   // Lädt alle PlugIns
   procedure LoadAllPlugIns;
   // Gibt alle PlugIns frei
   procedure FreeAllPlugIns;
end;

// Ereignisbehandlung für die Menüs, der PlugIns
class procedure TForm1.OnPlugInMenuClick(sender : TObject);
var
      evt : TOnCallFunc;
begin
   if sender is TMenuItem then
      with sender as TMenuItem do
         if (Tag >= 0) and (Tag < count_) then begin
            evt := TOnCallFunc(GetProcAddress(plugIns_[Tag], 'OnCall'));
            if evt <> nil then
               evt;
         end;
      end;
end;

   // Lädt alle PlugIns
procedure TForm1.LoadAllPlugIns;
var
   files : TStringList;
   i : Integer;   
   nameF: TGetNameFunc;
   name : String;
   menu : TMenuItem;
begin
   count_ := 0;
   files := TStringList.Create;
   try
      GetPlugInNames(ExtractFilePath(Application.Name) + 'PlugIns', files);
      for i:=0 to files.Count - 1 do begin
         plugIns_[count_] := LoadLibrary(files.Strings[i]);

         nameF:= TInitFunc(GetProcAdress(h, 'Init'));
         if not initF(name) then
            FreeLibrary(plugIns_[count_])
         else begin
            menu := TMenuItem.Create(mnuHauptEintrag);
            menu.Caption := name;
            menu.OnClick := OnPlugInMenuClick;
            menu.Tag := count_;
            mnuHauptEintrag.Items.Add(menu);
         end;
         Inc(count_);
      end;
   finally
      files.Free;
   end;
end;

// Gibt alle PlugIns frei
// dabei beschränkt sich die Prozedur nur auf das Freigeben der Dlls, 
// und nicht das Löschen der Menüs
procedure TForm1.FreeAllPlugIns;
var 
   i : Integer;
begin
   for i := 0 to count_ - 1 do
      FreeLibrary(plugIns_[i]);
   count_ := 0;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

For i := 0 to Items.Count - 1 do
  Begin
   DLLHandle     := LoadLibrary(PChar(Items.Strings[i]));
   GetPluginName := TGetPluginName(GetProcAddress(DLLHandle,'PluginName'));

   NewItem         := TMenuItem.Create(nil);
   Newitem.Caption := GetPluginname;
   NewItem.Tag     := Anzahl;
   NewItem.OnClick := PluginsOnClick;
   PluginMenu.Add(NewItem);
   Inc(anzahl);
  End;//For...                    

1:

  NewItem.OnClick := PluginsOnClick;                    

1:
2:
3:
4:
5:
6:

  Interface

   ...

  Class Procedure PluginsOnClick(Sender: TObject);
  Procedure LoadPlugins(Pfad: String; Pluginmenu:TMenuItem);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

Class Procedure PluginsOnClick(Sender: TObject);
Begin
 If Sender is TMenuItem then
  Begin
   With Sender as TmenuItem do
    Begin
     
    End;
  End;

End;                    

1:

[Fehler] Plugin.pas(49): Inkompatible Typen: Methodenzeiger und reguläre Prozedur                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:

Procedure TDeineKlasse.PluginsOnClick(Sender: TObject); 
Begin 
 If Sender is TMenuItem then 
  Begin 
   With Sender as TmenuItem do 
    Begin 
      
    End; 
  End; 

End;                    

1:

 FileExists('../datei.dll')                    

1:
2:

  GetPluginName := TGetPluginName(GetProcAddress(Plugins_[Count_],'PluginName'));
  Init := TInit(GetProcAddress(Plugins_[Count_],'Init'));                    

1:
2:
3:
4:
5:
6:
7:
8:

If GetProcAddress(Plugins_[Count_],'PluginName') = NIL then
 Begin
  // Wenn Function nicht Vorhanden
 End
  Else
   Begin
    // Ereignis wenn Function vorhanden
   End;