Was ist Prism?
Prism ist ein sehr junges Projekt der Microsoft patterns & practices Entwickler. Es wird samt Source Code bei Codeplex gehostet. Die Projekt-Homepage lautet
http://www.codeplex.com/prism.
Zu beachten ist, dass das Prism-Projekt momentan in einem sehr frühen Pre-Alpha-State existiert. Aber das Projekt-Team veröffentlicht neue Versionen in sehr kurzen Zyklen. Zum aktuellen Zeitpunkt gibt es bereits die vierte Veröffentlichung.
Das Ziel von Prism ist es, Programmierern und Architekten eine Anleitung zur Erstellung zusammengesetzter WPF-Anwendungen zu bieten.
Nun möchte man sagen: "Oh, das ist dann das 513. Framework für Composite Applications". Ich vermute mal, dass ich nicht der Einzige bin, der ein deja vú hatte beim ersten Lesen über Prism. Immerhin haben wir den "Composite Application Block" (CAB), die "Smart Client Software Factory" (SCSF), diverse Contribution-Projekte sowohl für CAB als auch für SCSF und dann ist da ja auch noch "Acropolis". Wofür brauchen wir jetzt also noch ein weiteres Framework?
Stopp! Und ab hier ganz langsam!
Denn niemand sagte, dass es sich um ein Framework handelt. Und das ist es auch, wodurch sich Prism von den anderen Projekten unterscheidet. Es gibt Anleitungen und steht gewissermaßen beratend zur Seite. Es enthält zwar ein kleines Framework, aber dabei handelt es sich um ein reines Nebenprodukt. Es kristallisierte sich beim Erarbeiten von Prism heraus und wird als Teil des Paketes mit ausgeliefert.
Ein weiteres wichtiges Merkmal von Prism ist, dass es für die Erstellung von WPF-Anwendungen konzipiert und optimiert wurde.
Die folgenden Punkte sind weitere Ziele, die sich das Prism-Team noch so auf die Fahnen geschrieben hat:
- Anwendungen können modular zusammengesetzt werden
- Die einzelnen Module können von voneinander unabhängigen Teams entwickelt, getestet und ausgeliefert werden
- Nutzeroberflächen können dynamisch zusammengesetzt werden
- Bestehende Anwendungen können schrittweise angepasst werden
Woraus besteht Prism?
Schauen wir uns das Ganze doch mal etwas genauer an.
Das Kernstück des Projektes ist die Referenzimplementierung "Stock Trader". Es handelt sich dabei um eine Beispielanwendung die sämtliche Konzepte und Patterns demonstrieren soll, die für die Entwicklung modularer und zusammengesetzter WPF-Anwendungen empfohlen werden.
Mitgeliefert wird der Quelltext der Referenzimplementierung und des dafür verwendeten Frameworks. Der Source Code ist versehen mit umfangreichen Unit- und Akzeptanztests. Damit ist es möglich die Funktionsweise der verschiedenen Komponenten sehr leicht kennenzulernen und zu verstehen.
Neben Quelltext und den Unit-Tests enthält das Paket auch noch eine Dokumentation in Form eines CHM-Files. Darin wird das Projekt, die Referenzimplementierung und verwendeten Konzepte erläutert. Die Dokumentation enthält außerdem einen Quickstart und eine Reihe von How-To-Anleitungen.
Welche Konzepte werden verwendet?
Das Problem, das Prism lösen möchte, ist die Entwicklung großer Projekte, indem die Funktionalität und die Nutzeroberfläche in verschiedene Module ausgelagert werden. Das erlaubt die Entwicklung abgeschlossener und unabhängiger Anwendungsteile. Das Angenehme daran ist, dass das automatisierte Testen mittels Unit-Testing enorm erleichtert wird. Das ist immer ein großes Problem bei der Entwicklung umfangreicher monolithischer Anwendungen gewesen.
Module
Der Schlüssel bei der Entwicklung zusammengesetzter Anwendungen ist die Auslagerung von Funktionalität in sogenannte Module. Eine Shell-Anwendung ist dann in der Lage, diese Module zu laden und in der Hauptanwendung zu hosten. Die Shell-Anwendung ist also eine erweiterbare Hauptanwendung, die die Module verwaltet und einbettet.
Innerhalb eines Moduls sind die Masken und die Geschäftslogik definiert. Das Modul bestimmt welche Masken oder Maskenbestandteile wann und an welcher Stelle im Hauptprogramm erscheinen sollen.
Um ein Modul zu entwickeln sollte eine Klasse geschrieben werden, die die Schnittstelle IModule aus dem Namespace Prism.Interfaces implementiert:
public class MyModule : IModule
{
public void Initialize()
{
// Initialisierung des Moduls
}
}
Das IModule-Interface besitzt momentan eine einzige Methode, die implementiert werden muss. Initialize() wird vom Framework beim Laden des Moduls aufgerufen. Hier müssen sämtliche Initialisierungen des Moduls stattfinden. Dazu gehört in der Regel die Einrichtungen der einzelnen Views und der Services, die vom Modul angeboten werden.
Es gibt mehrere Möglichkeiten Module zu laden. Zum Beispiel können Module in der Anwendungskonfigurationsdatei deklariert werden. Die dort eingetragenen Module werden beim Programmstart geladen.
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<configSections>
<section name="modules" type="Prism.Configuration.ModulesConfigurationSection, Prism"/>
</configSections>
<modules>
<module assemblyFile="Modules/MyModule.dll" moduleType="MyModule.MyModule" moduleName="MyModule">
</module>
</modules>
</configuration>In dieser Konfigurationsdatei ist es möglich mehrere Module anzugeben und Abhängigkeiten zwischen ihnen festzulegen. Dadurch kann die Lade-Reihenfolge beeinflusst werden.
Regions
Als Region wird der Bereich der Benutzeroberfläche bezeichnet, die erweiterbar ist. Sind Regions in der Anwendung definiert, können Module darin sogenannte Masken und Maskenbestandteile anzeigen.
Im Xaml-Code können Controls folgendermaßen als Regions deklariert werden:
<TabControl prism:RegionManager.Region="MainRegion" />
Das TabControl ist nun eine Region, die "MainRegion" genannt wurde. Über diesen Namen ist es Modulen nun möglich darin dynamisch Views abzulegen.
public void ShowView(IRegionManagerService regionManagerService)
{
MyView myView = new MyView();
IRegion targetRegion = regionManagerService.GetRegion("MainRegion");
targetRegion.Add(myView);
targetRegion.Show(myView);
}
Commands
Für die Kommunikation in WPF gibt es das Konzept der Commands. Prism unterstützt dieses Konzept indem es zwei Arten von Commands zur Verfügung stellt: das CompositeCommand und das DelegateCommand.
Ein CompositeCommand ist ein Command, welches mehrere Commands zusammenfasst und ausführen kann. Das bietet sich zum Beispiel für Operationen an, die global für die gesamte Anwendung zur Verfügung stehen sollen.
Eine Umsetzung sieht vor, dass dafür eine statische Command-Klasse existiert:
public static class MyCommands
{
public static CompositeCommand MyCompositeCommand = new CompositeCommand();
}
Dieses Command kann nun bspw. an ein Button-Control gebunden werden:
<Button Command="{x:Static local:MyCommands.MyCompositeCommand}">Go</Button>Mehrere Commands können nun dem CompositeCommand hinzugefügt werden:
MyCommands.MyCompositeCommand.RegisterCommand(myCommand1);
MyCommands.MyCompositeCommand.RegisterCommand(myCommand2);
Das DelegateCommand ist eine einfache Implementierung des ICommand-Interface. Es delegiert die Execute- und CanExecute-Aufrufe an Methoden weiter, die dem Command-Objekt im Konstruktor übergeben wurden.
Es muss also eine Command-Instanz erzeugt werden:
var myCommand = new DelegateCommand<MyParameters>(OnExecuted, OnCanExecute);
Nun müssen die entsprechenden Behandlungsroutinen implementiert werden:
void OnBuyExecuted(MyParameters parameters)
{
//Geschäftslogik
}
bool OnBuyCanExecute(BuyParameters buyParameters)
{
//Geschäftslogik
return true;
}
Um das Command zu nutzen, braucht es nur an das entsprechende Control gebunden werden:
view.DataContext = myCommand;
<Button Command="{Binding}">Go</Button>Fazit
Dieser Artikel ist eine kurze Einführung in Prism. Die hier gezeigten Beispiele sind nur ein kleiner Teil des Gesamten Projektes. Im momentanen Zustand ist es noch nicht möglich damit große Anwendungen zu entwickeln. Dennoch sind bereits jetzt eine ganze Reihe interessanter Konzepte daraus abzulesen.
Es bleibt auzuwarten, wie sich das Ganze entwickeln wird. Aber schon jetzt kann durch das Lesen des mitgelieferten Quelltextes eine ganze Menge gelernt werden.
Links