MahApps.Metro in Verbindung mit der PRISM-Bibliothek (Teil 3: Erstellung von Modulen)

In den ersten beiden Artikeln

ging es um die Erstellung der eigentlichen Solution und die Einteilung des Hauptdialogs in einzelne Regionen. Dieser Artikel beschreibt jetzt die Erstellung von PRISM-Modulen und wie diese innerhalb der Anwendung interagieren, z.B. Zugriff auf die Regionen und Registrierung von Views. Dabei wird zunächst gezeigt wie ein solches Modul erstellt wird und wie das erstellte Modul dann innerhalb der Anwendung verwendet werden kann.

Um ein PRISM-Module zu erstellen sind grundsätzlich zwei Schritte notwendig

  1. Erstellung des Moduls – Module sind Klassen, die das Interface IModule implementieren
  2. Registrierung des Moduls – Für die Registrierung eines Modus gibt es die folgenden Möglichkeiten:
    • Direkt im Code (Bootstrapper) – Module können direkt im Code registriert werden. Dafür stellt der Applicaton-Bootstrapper die Methode ConfigureModuleCatalog bereit. Hier können dann z.B. Berechtigungsprüfungen durchgeführt werden und man kann genau steuern welche Module geladen werden. Dafür muss das Shell-Projekt das Modul allerdings referenzieren.
    • Per Konfiguration – mit dieser Methode werden die Module via Konfiguration bereitgestellt. Hierfür werden keine Referenzen benötigt und die Module werden unabhängig von der Applikation geladen.
    • Laden aus einem Verzeichnis – hier wird ein Verzeichnis festgelegt aus welchem die Module geladen werden sollen.

Erstellung eines PRISM-Moduls

Um ein neues Modul zu erzeugen legen wir zunächst ein neues Projekt an. Dieses Projekt ist eine normale Klassenbibliothek:

PrismMahAppsSample_11

Wie weiter oben schon geschrieben muss ein PRISM-Modul das Interface IModule implementieren. Dieses Interface besitzt lediglich eine Methode und ist wie folgt aufgebaut:

Wie der Name der Methode schon vermuten lässt wird das Modul hier initialisiert, d.h. hier werden z.B. Berechtigungen geprüft, Views geladen und innerhalb des RegionManagers registriert usw. In den bisherigen Projekten habe ich immer eine Basisklasse (PrismBaseModule) für PRISM-Module verwendet, die dieses Interface implementiert und wie folgt aufgebaut ist:

Diese Basisklasse befindet sich im allgemeinen Projekt PrismMahAppsSample.Infrastructure und muss dann von dem neuen Modul referenziert werden. Hat man das Projekt angelegt, sollte das dann wie folgt aussehen:

PrismMahAppsSample_14

Die Implementierung des eigentlichen Moduls ist dann ganz einfach. Man muss lediglich von der Basisklasse ableiten und ist fertig:

Damit wäre das Basismodul soweit fertig. Ziel ist es ja aber, dass wir aus unserem Modul heraus Views im Hauptfenster registrieren. Dafür habe ich in diesem Beispielmodul mal entsprechende Views erstellt und diese werden dann wie folgt registriert:

PrismMahAppsSample_15

Hier werden jetzt im Constructor des Moduls die einzelnen Views den vorher erstellten Regionen zugeordnet. Die Views haben dabei keinerlei Kenntnis vom Hauptfenster und wo sie innerhalb des Hauptfensters angezeigt werden. Den Rest übernimmt dann die PRISM-Bibliothek. Hier könnte man jetzt z.B. noch Berechtigungsprüfungen durchführen und dem Benutzer nur die Views anzeigen für die er auch Berechtigungen hat.

Registrierung des Moduls

Wie schon geschrieben gibt es verschiedene Möglichkeiten PRISM-Module zu registrieren. Hier zeige ich die Registrierung direkt im Code über den Bootstrapper. Innerhalb des Bootstrapper muss dafür die Methode ConfigureModuleCatalog überschrieben werden. Die sieht dann im Beispielprojekt wie folgt aus:

Damit ist man mit der Erstellung des Moduls fertig und das Hauptfensters sollte dynamisch durch die Module erweitert werden. Hier sollte die Shell bzw. das Hauptfenster jetzt wie folgt aussehen:

PrismMahAppsSample_13

Github-Repository

Der aktuellste Quellcode ist in folgendem Github-Repository verfügbar: https://github.com/steve600/PrismMahAppsSample

Fork me on GitHub