In diesem Tutorial wird erklärt, wie Plugins in eigene Programme eingebaut werden können. Plugins sind spezielle Erweiterungen, mit welchen die Funktionalität eines Programms erweitert werden kann. Die Verwendung von Plugins bringt einige Vorteile wie z.B.

• Es können nachträglich neue Funktionen hinzugefügt werden, ohne den Original-Programmcode verändern zu müssen.
• Plugins kann prinzipiell jeder entwickeln, der weiß auf welche Methoden unser Programm zugreift. Damit können dann Dritte die Funktionalität unseres Programm erweitern.
• Unser Programm wird flexibler und leichter Erweiterbar

Um die Nutzung von Plugins zu verdeutlichen werden wir ein kleines Beispielprojekt erstellen.

Mit freundlichen Grüßen
Johannes Pfeiffer  johannes@activevb.de

Inhalt

	Übersicht
	Objekte aus DLLs erstellen
	Mehrere PlugIns verwalten
	PlugIns ausführen
	Registrierung sauber halten
	Fehlerbehandlung
	Methoden des PlugIns
	Schlußwort

Unser Beispielprogramm soll Rechnungen mit zwei Zahlen durchführen. Je nach ausgewähltem Plugin kann das Programm dann verschiedene Rechnungsarten durchführen. (Addieren, Dividieren, Potenzieren...)

Abbildung 1: Screenshot

Im 1. Schritt soll man das Plugin (und damit die Rechenfunktion) auswählen. Dann gibt man zwei Zahlen für die Rechnung ein. Dann lässt man das Plugin die Rechnung durchführen.

Wie gerade erwähnt wählen wir am Anfang in unserem Programm ein Plugin aus. Plugins sind hier nichts anderes als DLLs. Wir müssen also ein Objekt aus einer DLL erstellen. Dazu verwenden wir die CreateObject Funktion. In der Praxis sieht das so aus: Wir haben eine DLL die Grundrechnen heißt. In dieser DLL gibt es die Klasse Addieren. Um diese Klasse (Addieren) in unserem Projekt verwenden zu können erstellen wir sie folgendermaßen:

Dim obj As Object
Set obj = CreateObject("Grundrechnen.Addieren")

Listing 1

Die Klasse Addieren besitzt die Methode "execute", welcher man als Parameter zwei Zahlen übergeben muss. Hier z.B. 10 und 4.

Msgbox obj.execute (10,4)

Listing 2

Damit man ein Objekt mit CreateObject erstellen kann muss die DLL allerdings vorher registriert worden sein. Wir machen es uns leicht und verwenden einfach einen Tipp von ActiveVB.de "Registrieren von DLLs zur Laufzeit". Nachdem wir das Modul eingebunden haben können wir die Funktion RegServe benutzen. Als Parameter verlangt sie den DLL-Dateinamen und dann entweder True für das Registrieren oder False für das Unregistrieren der DLL.

Gut, wir wissen jetzt wie man mit CreateObject ein Objekt erstellen kann. Der Code ist aber noch nicht fähig mehrere Plugins zu verwenden, da bei unserem obigen Beispiel immer nur auf ein und dieselbe DLL (Grundrechnen) zugegriffen wird. Deshalb erstellen wir eine Textdatei in die wir alle unsere Plugins eintragen. Unser Programm geht dann alle Einträge durch und fügt die Beschreibung der Objekte einer Auswahlliste hinzu. Aus dieser Liste können wir dann später bequem unser Plugin auswählen. Die Beschreibung bekommen wir aus der Methode info (die wir also jedem Plugin geben müssen). Für die spätere Erstellung mit CreateObject brauchen wir nochmals den DLL-Namen und die Klasse also sichern wir gleichzeitig diese Information in der Collection PluginClass ab.

Open App.Path & "\plugins.txt" For Input As #1
    While Not EOF(1)
        Line Input #1, strClass
            Set obj = CreateObject(strClass)
            Combo1.AddItem obj.info
            PluginClass.Add strClass
    Wend
Close #1

Listing 3

Wie gesagt: Alle DLLs müssen vorher noch registriert werden. Dazu schreiben wir vor jede Zeile noch den DLL-Dateinamen (z.B. test.dll). Um den Dateinamen von der Klasse zu trennen setzen wir ein Komma dazwischen. z.B. "test.dll,simple.Addieren" Im Programm zerlegen wir diesen String mithilfe der Split-Funktion.

While Not EOF(1)
    Line Input #1, strClass

    'Den Dateinamen vom Klassennamen trennen 
    strDllClass() = Split(strClass, ",")

    If Not Left(strDllClass(0), 2) = "//" Then   'Kommentare übergehen 
      'Die Dll registrieren 
      RegServe App.Path & "\" & strDllClass(0), True 
    
      'In Collections hinzufügen 
      PluginDll.Add strDllClass(0)
      PluginClass.Add strDllClass(1)

      'Objekt erstellen und Beschreibung in Liste hinzufügen 
      Set obj = CreateObject(strDllClass(1))
      Combo1.AddItem obj.info
   End If 
Wend

Listing 4

Um uns dann das Ergebnis berechnen zu lassen benutzen wir die Methode execute des Objektes:

Dim obj As Object
 
'Das Objekt erstellen 
Set obj = CreateObject(PluginClass(Combo1.ListIndex + 1))
 
'Ergebnis berechnen 
Ergtxt.Text = obj.execute(CLng(xtxt.Text), CLng(ytxt.Text))

Listing 5

Wir erstellen einfach das Objekt und führen dann die Methode execute aus. Als Parameter übergeben wir ihr den Inhalt der beiden Textfelder x und y. Das Ergebnis erscheint dann in der Textbox Ergtxt. Registriert worden ist die DLL ja schon beim Hinzufügen zur Auswahlliste (am Anfang), deshalb müssen wir es hier nicht wiederholen.

Wenn unser Programm beendet wird dann sollen die DLLs wieder unregistriert werden. Schließlich wollen wir die Registrierung des Users nicht noch mit unserem Programm zusätzlich zumüllen.

Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer)

  Dim i As Long 

    For i = 1 To PluginDll.Count
      RegServe App.Path & "\" & PluginDll(i), False 
    Next i

End Sub

Listing 6

Was ist aber wenn jemand ein "falsches" Plugin programmiert? Dadurch würde unser Programm instabil werden. Um dies zu umgehen testen wir beim Start mit einer Funktion ob die Plugins alle Methoden enthalten die wir wünschen. Plugins welche unsere Anforderungen nicht erfüllen können werden nicht geladen. Das können wir mithilfe einer Funktion testen, die erst einmal davon ausgeht das alles richtig läuft. Dort werden alle Funktionen getestet. Passiert nichts, waren die Tests erfolgreich. Bei einem Fehler springt das Programm allerdings zum ErrorHandler und hat somit den Rückgabewert False.

On Error Goto Nicht_Bestanden

Set obj = CreateObject(PluginCLS)

'Testen ob benötigte Funktionen vorliegen 
strTest = obj.info
strTest = CStr(obj.execute(1, 1))

'Alle Tests bestanden 
Plugin_testen = True 
Exit Function 

'Bei Fehler Tests nicht bestanden 
Nicht_Bestanden:
Plugin_testen = False

Listing 7

Jetzt binden wir diesen Test in die Funktion Plugins_suchen ein. Damit haben wir unser Hauptprogramm auch schon fertig geschrieben. Um alles nachvollziehen zu können sollten sie sich das Beispielprojekt noch mal anschauen. Jetzt benötigen wir nur noch unsere Plugins.

Jedes Plugin (ActiveX-DLL) für unser Programm muss die Methoden info und execute enthalten. Also erstellen wir jetzt ein neues ActiveX-DLL-Projekt für unser Plugin.

Die Methode info gibt einfach einen String zurück, in dem die DLL kurz beschrieben wird. Dieser Text erscheint dann in unserer Auswahlliste.

Function info() As String
   info = Addieren (x + y)
End Function

Listing 8

Nun zur Methode execute. Hier findet die eigentliche Berechnung statt.

Function execute(x As Long, y As Long) As Long
  execute = x + y
Exit Function

Listing 9

Das war es schon gewesen. Wir haben unser erstes Plugin entworfen. Erstellen wir nun die DLL und kopieren diese ins Hauptverzeichnis unseres Programms. Dann fügen sie in die Textdatei (plugins.txt) noch die DLL ein: DLL-Dateiname,DLL-Name.Klasse (Hinweis: Der DLL-Name ist der Projektname).

Wenn wir jetzt das Programm starten, können wir es in der Liste auswählen. Damit haben wir das Plugin erfolgreich ins Programm eingebunden. Man könnte z.B. jetzt noch weitere Plugins entwerfen z.B. Quadratwurzelziehen, Potenzieren, Dividieren… Es gibt noch viele Möglichkeiten.

Plugins können in vielen Situationen sehr nützlich sein. Ich hoffe es konnte mit diesem Tutorial klar werden wie man Plugins in ein Programm einbauen kann. Fragen werden gerne von mir beantwortet.

Tutorial und Beispielprojekt als Download