C# - PROGRAMME MIT PLUGINS ERWEITERN

Transkript

1 C# - PROGRAMME MIT PLUGINS ERWEITERN Schreibt man ein Programm welches erweiterbar sein soll, dann gibt es häufig mehrere Möglichkeiten dies umzusetzen. Die Objektorientierung ist dabei der erste Schritt, da eine Erweiterbarkeit immer mit einer gut umgesetzten Modularisierung und Kapselung anfängt. Hat man eine Basis geschaffen wird sie in ein Programm gegossen und veröffentlicht. Damit ist der erste Schritt getan (vereinfacht gesprochen). Nun kommt der Zeitpunkt, an dem noch Funktionalität hinzugefügt werden soll z.b. Ein Report soll generiert werden, oder ein Diagramm soll angezeigt werden, oder irgend eine Berechnung soll durchgeführt werden. Normalerweise öffnet man nun sein Projekt, schreibt ein paar Klassen und Methoden drückt auf Kompilieren und die neue Version ist fertig. Nachteil bei der ganzen Sache nur der Programmierer, der das Programm geschrieben hat, bzw. den Quelltext hat, kann Funktionalität hinzufügen. Das ist der Punkt an dem Plugins ansetzen. Der Programmierer der eine Software entwickelt stellt eine Schnittstelle bereit um jedem (und sich selbst) zu ermöglichen Funktionen hinzuzufügen, ohne die eigentliche Programmbasis angreifen zu müssen. Darüber hinaus ist es nun möglich, dass der Nutzer nur die Funktionalität bekommt die er auch braucht, ohne lange konfigurieren zu müssen. Das Prinzip von Plugins ist z.b. vom Firefox-Browser gut bekannt bei dem Zusatzfunktionalität über das eigentliche Programm hinaus (jedoch auf ihm basierend) angeboten werden. Um diesen Ansatz in C# für einen selbst nutzbar zu machen gibt es ein einfaches Verfahren welches ich im Folgenden vorstellen möchte. Dabei sei gesagt, dass es sich nicht um eine Muster-Implementation handelt, sondern lediglich um eine Prinzip-Studie. Grundlage für die Erweiterbarkeit durch Plugins ist eine Programm-Basis welche Plugins verwenden kann. Nehmen wir an, wir schreiben ein Programm zur persönlichen Zeiterfassung in dem wir unsere Tätigkeiten mit Datum und Stundenaufwand erfassen können. Dieses Programm soll grundlegend erst einmal die Möglichkeit bieten eine Tätigkeit anzulegen, sie zu bearbeiten (korrigieren) und sie ggf. wieder zu löschen. Die Tätigkeiten sollen in einer Datenbank (z.b. SQLite) abgelegt werden. Nehmen wir an, wir hätten dieses Programm soweit, dass die Programmbasis steht und funktioniert. (siehe Abbildung 1) Nun fällt einem auf, dass die einzelnen Tage nicht sehr gut als zusammenhängender Block zu erkennen sind. An dieser Stelle nun wollen wir ein Plugin verwenden, welches zusammenhängende Tage (dem Datum nach) farblich voneinander abhebt. Wir gehen dabei wie folgt vor: 1. Im Hauptprogramm wird eine Schnittstelle bereitgestellt, welche später von jedem Plugin implementiert werden soll. Schnittstelle aus Punkt 1 implementiert. 2. Es wird neues Projekt für das Plugin erstellt dem eine Referenz auf die Assembly des Hauptprogramms hinzugefügt wird. In diesem Projekt wird nun eine Klasse erstellt, welche die 3. Im Hauptprogramm muss nun noch die Funktionalität implementiert werden, welche die fertige Assembly des Plugins lädt und eine Instanz davon erstellt und bedient.

2 using System; using System.Windows.Forms; using System.Data.SQLite; using System.Data; namespace Zeiterfassung /// <summary> /// Interface welches jedes Plugin implementieren muss /// um von der Zeiterfassung verwendet werden zu können /// </summary> public interface IZeitPlugin void Init(MainForm MainForm, SQLiteConnection Connection); void RefreshView(); void Shutdown(); später ermöglichen möchte, stelle ich entsprechende Informationen bereit. Beginnen wir bei Punkt 1 der Schnittstelle (Listing 1). Generell gibt es viele Möglichkeiten ein Interface für ein Plugin zu gestalten es kommt auf die Möglichkeiten an, welche ein Plugin später bieten können soll. Möchte ich einem Plugin ermöglichen die Oberfläche meine Applikation anzupassen oder zu verändern, langt es ihm die entsprechenden Informationen z.b. das MainForm oder das MainMenu zu übergeben. Möchte ich aber, dass es darüber hinaus noch mehr kann, so muss ich auch das Interface entsprechend gestalten. Je nach Umfang des Eingriffs, den ich den Plugins In unserem Fall habe ich vorgesehen, dass Plugins nicht nur auf die Oberfläche des Programms zugreifen können, sondern auch auf die SQLiteConnection welche im Programm verwendet wird. Mein Interface bietet daher die Methode Init welcher die eben genannten Referenzen übergeben werden. Sie wird aufgerufen, sobald ein Plugin geladen wird. Damit das Plugin wieder aus der Software auskoppelt kann (weil ich das Plugin z.b. abwähle oder die Software schließe gibt es eine Methode Shutdown welche dem Plugin die Möglichkeit gibt, auf diese Ereignisse zu reagieren. (z.b. Menüeinträge die mit Laden des Plugins angelegt wurden wieder auszublenden etc.) Zu Guter Letzt gibt es noch eine Methode RefreshView welche dem Plugin signalisieren soll, dass für die Anzeige relevante Daten aktualisiert werden müssen / sollen. Dieses Interface bildet so den Rahmen für alle Plugins und ich muss mir beim Entwurf im Klaren darüber sein, dass Dinge die hier fehlen später nur schwer hinzugefügt werden könne, da alle Plugins auf dieser Schnittstelle basieren. Ändere ich das Interface sind die Plugins nicht mehr kompatibel, da sie gegen das alte Interface kompiliert wurden und jetzt zuerst das neue implementieren müssen. Es ist also nötig große Vorsicht walten zu lassen und vorausschauend das Interface zu planen. Kommen wir nun zu Punkt 2 der Implementation des Plugin (Listing 2).

3 using System; using Zeiterfassung; using System.Windows.Forms; using System.Data.SQLite; using System.Data; using System.Drawing; namespace PluginBlockColor /// <summary> /// BlockColor. /// </summary> public class BlockColor : IZeitPlugin private MainForm mainform = null; private SQLiteConnection connection = null; public BlockColor() public void Init(MainForm MainForm, System.Data.SQLite.SQLiteConnection Connection) mainform = MainForm; connection = Connection; public void RefreshView() string columnvalue = null; Random rnd = new Random(DateTime.Now.Millisecond); bool bright = true; Color rowcolor = Color.FromArgb(220 + rnd.next(35), rnd.next(35), rnd.next(35)); foreach (DataGridViewRow row in mainform.dgvzeiten.rows) if (columnvalue == null) columnvalue = row.cells["columndatum"].value.tostring(); if (columnvalue!= row.cells["columndatum"].value.tostring()) columnvalue = row.cells["columndatum"].value.tostring(); if (bright) rowcolor = Color.FromArgb(220 + rnd.next(35), rnd.next(35), rnd.next(35)); bright = false; else rowcolor = Color.FromArgb(150 + rnd.next(35), rnd.next(35), rnd.next(35)); bright = true; foreach (DataGridViewCell cell in row.cells) cell.style.backcolor = rowcolor; public void Shutdown()

4 Unser Plugin nennt sich BlockColor und implementiert wie bereits geschildert unser Interface. Dabei werden die Referenzen auf das MainForm und die SQLiteConnection, die an Init übergeben werden, als Felder gespeichert und können anschließend in RefreshView angesprochen werden. Die Funktionsweise des Plugins werde ich nur kurz erläutern: wird RefreshView aufgerufen, so wird das als public deklarierte DataGridView auf dem MainForm durchlaufen und geprüft ob in der Zelle für das Datum, der gleiche Wert steht wie in der vorhergehenden Zeile wenn ja, so wird die gleiche Farbe wie in der vorhergehenden Zelle verwendet, ansonsten eine neue (zufällig erstellte). Was sich ergibt sind zusammenhängende mit der gleichen Farbe gekennzeichnete Blöcke (darum auch BlockColor). Die Methode Shutdown ist nicht implementiert obwohl hier denkbar wäre, dass sie alle Zellen / Zeilen wieder auf einen weißen Hintergrund zurücksetzt. Damit ist unser Plugin eigentlich schon fertig es muss nur noch geladen und angesprochen werden und damit sind wir am Punkt 3 angelangt. Der Lade- / Management-Funktionalität im Hauptprogramm (Listing 3). void LoadPlugins() if (Directory.Exists(pluginsPath)) DirectoryInfo dir = new DirectoryInfo(pluginsPath); FileInfo[] files = dir.getfiles("*.dll"); foreach (FileInfo file in files) Assembly pluginassembly = Assembly.LoadFrom(file.FullName); foreach (Type type in pluginassembly.gettypes()) if (type.getinterface("izeitplugin")!= null) IZeitPlugin plugin = (IZeitPlugin)Activator.CreateInstance(type); plugin.init(this, connection); plugins.add(plugin); IZeitPlugin (unser Plugin-Interface) implementieren. Hier passiert die eigentliche Arbeit: Es wird überprüft ob ein Plugin-Pfad existiert (aus dem die Assemblies für die Plugins geladen werden) Wenn ja werden alle *.dll-dateien aus diesem Verzeichnis der Reihe nach geladen (Assembly.LoadFrom). Aus der jeweiligen Assembly werden alle Typen (also Klassen) geladen der Reihe nach durchgeschaut ob sie ein Interface mit Namen Ist dies der Fall so wird von dem jeweiligen Typ / der jeweiligen Klasse eine Instanz erstellt (Activator.CreateInstance) welche dann über das Interface angesprochen werden kann (Basisklassen- Pointer bzw. Interface-Pointer). Sofort nach dem Erstellen einer Instanz deren Methode Init aufgerufen und die entsprechenden Informationen übergeben. Nun wird das Objekt nur noch in der Liste für geladene Plugins abgelegt und ist nun im Hauptprogramm aktiv. Diese Methode ist in MainForm selbst zu platzieren und natürlich sind die entsprechenden privaten Felder für die Plugin-Liste und den Plugin-Pfad anzulegen und zu konfigurieren. Um anschließend Plugins zu laden, einfach die Methode LoadPlugins im Event-Handler MainFormShown aufrufen. Starten wir so unsere Zeiterfassung sehen wir, dass wir nichts sehen denn die Methode RefreshView wird noch nirgendwo aufgerufen.

5 In meinem Fall habe ich eine Methode RefreshDB welche die Daten aus der Datenbank lädt und anzeigt, wenn Änderungen, Löschungen oder neue Einträge erfolgt sind. In dieser Methode durchlaufe ich einfach die Liste der Plugins und rufe für jedes die Methode RefreshView auf (Listing 4) foreach (IZeitPlugin plugin in plugins) plugin.refreshview(); Wenn jetzt noch die Shutdown -Methode auf die gleiche Weise im Event-Handler MainFormClosing aufruft, dann ist man mit dem Hauptprogramm fertig und kann sich immer neue Plugins ausdenken. Das Ergebnis des eben entworfenen Plugins soll natürlich auch betrachtet werden können: Ich hoffe ich konnte euch das Prinzip und auch die konkrete Implementierung etwas näher bringen. Es handelt sich bei dieser Zeiterfassung nicht um ein esoterisches Beispiel ich habe sie Tatsächlich in Gebrauch. Mittlerweile haben sich noch ein paar Plugins hinzugesellt: PluginSummen: Berechnet die Summe des Stundenaufwandes über alle in der Liste markierten Zeilen (Kontext-Menü-Eintrag) PluginÜberstunden: Zeigt mir für (m)eine Wochenarbeitszeit von 37 Stunden (Mo-Do = 8h, Fr = 5h) an, wie viele Überstunden ich schon gemacht habe. PluginSuchfunktionen: Da sagt der Name eigentlich alles. PluginReports: Erstellt mir verschiedene Reporte, angefangen von der einfachen Übersicht über die Stunden des Monats bis hin zur Tortengrafik über die Zeiten pro Tätigkeit in einem Monat.

6 Ihr könnt das fertige Programm, sowie auch die Solution bei mir hier downloaden. Eine kleine Entschuldigung vorab: das Programm ist ein bisschen Quick&Dirty implementiert, weil es von mir tatsächlich dringend gebraucht wurde. Ich bitte einfach darüber hinweg zu sehen in der Hauptsache geht es um den Plugin- Mechanismus.