Wie baue ich eine Software Factory (Teil 2)?
Im ersten Teil habe ich die Grundvoraussetzungen betrachtet und das Beispiel-Package des Guidance Automation Toolkit compiliert und gestartet. Das Beispiel ist ein wenig erschlagend wenn man sich die gesamten Verzeichnisse anschaut die in der Lösung miterstellt werden. Im heutigen Teil möchte ich kurz auf das Beispiel Projekt der Serie eingehen und ein weiteres Hello World Demo schreiben.
Das neue Projekt wird einfach "MyFactory" heißen. MyFactory wird ein Guidance Package sein die eine typisierte Directory Komponente erstellen kann. Was ist eine typisierte Directory Komponente? Nehmen wir folgenden Fall an: Im Unternehmen gibt es neben Active Directory noch zwei weitere Directories die im großen und ganzen die gleichen Attribute zur Verfügung stellen. Die Directories trennen logisch verschiedene Segmente im Unternehmen. Die Attribute sind jedoch Directory Ebene unterschiedlich benannt und müssen gesondert angesprochen werden. Des Weiteren gibt es gewisse Richtlinien wie eben mit diesen Directories gearbeitet werden darf. Es liegt auf der Hand eine standardisierte Komponente zu erstellen die für alle Entwickler die gleiche Zugriffslogik zur Verfügung stellt.
Jedes Projekt und jede Anwendung die eines der drei Directories nutzen, müssen Zugriff auf die einzelnen Directory Attribute beantragen. Die meisten Anwendungen dürfen sensible, vertrauliche Daten nicht lesen. Zum Beispiel darf eine Anwendung der Personalstelle durchaus Gehaltsstufen des Mitarbeiters aus dem Directory lesen, während eine Intranet Anwendung die für die Weiterbildung der Mitarbeiter verantwortlich ist lediglich deren Kontaktdaten lesen darf.
Welche Lösungsansätze gibt es?
a) Die generische Komponente
CompanyDirectory directory = new CompanyDirectory( CompanyDirectory.Directory1 );
DirectoryObject user = directory.FindUserByEmail( "[email removed]" );
// auslesen der Kontaktdaten
string name = user.Properties[ Attributes.Lastname ];
string phone = user.Properties[ Attributes.Telephone ];
// etc...
Mit einer generischen Komponente kann man den Fall gut lösen. Der Nachteil der sich hier ergibt sind Laufzeitfehler falls auf Eigenschaften zugegriffen wird die es nicht gibt oder die für die Anwendung nicht freigeschalten sind. Laufzeitfehler lassen sich sehr gut mit Unit Tests eliminieren, so das dies ein möglicher Ansatz wäre.
b) Die typisierte Komponente
CompanyDirectory directory = new ComponyDirectory( CompanyDirectory.Directory1 );
// es wird ein typisiertes User Objekt von der Methode erstellt
DirectoryUser user = directory.FindUserByEmail( "[email removed]" );
string name = user.Lastname;
string phone = user.Telephone;
// typisierte Zugriffe
Mit der typisierten Komponente läßt es sich leichter entwickeln. Attribute für die die Anwendung keinerlei Verwendung oder Rechte hat werden in einem solchen typisierten Objekt erst gar nicht aufrauchen. Durch die typisierung erhält man neben Intellisense Unterstützung auch noch kompilierfehler gemeldet falls etwas nicht stimmt. Es können auch hier Laufzeitfehler auftreten, allerdings mehr aus einer Anwendungsbezogenen Sicht heraus und seltener Aufgrund von ansprechen von Attributen.
Beide Ansätze verfügen über eine Konfigurationsdatei um das Mapping von Directory Attributen auf Objekt- bzw. PropertyBag Attribute zu bewerkstelligen. Ein Beispiel:
<!-- Directory 1 --/>
<attribute name="phone" property="Telephone"/>
<!-- Directory 2 --/>
<attribute name="phoneNumber" property="Telephone"/>
Der Entwickler programmiert gegen die Eigenschaft Telephone während diese im Directory 1 auf phone oder im Directory 2 auf phoneNumber gemappt ist. Ändert sich das Attribut in einem der Directories einmal kann man es in der Konfiguration nachziehen ohne die Anwendung neu übersetzen zu müssen.
Für das weitere Beispiel werde ich Methode B wählen.
Nachdem der Projekthintergrund für die Factory beschrieben ist, wird das eigentliche erstellte Package erstmal entrümpelt. Nach der Erstellung durch das Projekt Template erhält man folgende Projektstruktur:

Ich lösche erstmal alles bis auf MyFactory.xml und TypeAlias.xml.

Das sieht übersichtlicher aus und ist einfacher als Ausgangsbasis. Der Einstiegspunkt ist die MyFactory.xml package Beschreibung. Standardmässig wird alles in diese eine Package XML Datei gepackt. Dies ist sehr unübersichtlich und erschwert das arbeiten. Gut, das man diese Datei in mehrere aufsplitten kann. Hierzu bedient man sich dem XInclude.
Hier erstmal die veränderte MyFactory.xml.
<?xml version="1.0" encoding="utf-8" ?>
<GuidancePackage xmlns="http://schemas.microsoft.com/pag/gax-core"
Name="MyFactory"
Caption="MyFactory"
Description="A simple factory sample"
BindingRecipe="CreateBindings"
Guid="ef0581dd-9b0d-48ae-acd9-599d5a92fc6b"
SchemaVersion="1.0">
<Overview Url="documentation\Overview.htm"/>
<Recipes>
<xi:include href="Recipes\CreateBindings.xml"
xmlns:xi="http://www.w3.org/2001/XInclude"/>
<xi:include href="Recipes\HelloWorldSimpleRecipe.xml"
xmlns:xi="http://www.w3.org/2001/XInclude"/>
</Recipes>
</GuidancePackage>
In Zeile 11 und Zeile 13 werden weitere Dateien referenziert und somit die eigentliche Einstiegsdatei auf das wesentlichste reduziert.
Rezepte
Ein wichtiger Bestandteil von dem Guidance Automation Extensions ist das Rezept (Recipe). Ein Rezept enthält 1 bis mehrere Aktionen (Actions). Zum Beispiel kann ein Rezept die Aktionen Projekt Verzeichnis erstellen und Referenzen hinzufügen enthalten. Rezepte sind wirklich nur Sammlungen von Aktionen.
Aktionen
Eine Aktion (Action) ist die kleinste Einheit. Die abstrakte Basisklasse Action hat nur zwei Methoden zum implementieren: Execute() und Undo(). Dadurch lässt sich auch schon feststellen das Undo Operationen auf Rezept Ebene nicht vom Design unterstützt werden sondern mühselig in den Aktionen mit rein implementiert werden müssen. Diese sind somit nicht mehr als unabhängige Einheit untereinander zu betrachten sind. Für das Beispiel Projekt "MyFactory" ist das Undo von Aktionen nicht nötig.
Ein besonderes Rezept ist das BindingRecipe (Zeile 6). Dieses wird beim Laden des Packages ausgeführt und dient als Verknüpfungsrezept. Mögliche Rezepte werden so zu UI Elementenen hinzugeordnet.
Die CreateBindings.xml Datei bei mir sieht folgendermaßen aus:
<?xml version="1.0" encoding="utf-8" ?>
<Recipe xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
Name="CreateBindings"
xmlns="http://schemas.microsoft.com/pag/gax-core">
<Types>
<TypeAlias Name="RefCreator"
Type="Microsoft.Practices.RecipeFramework.Library.Actions.CreateUnboundReferenceAction,
Microsoft.Practices.RecipeFramework.Library"/>
</Types>
<Caption>All MyFactory Bindings</Caption>
<Actions>
<Action Name="EnableHelloWorldRef"
Type="RefCreator"
AssetName="HelloWorldSimpleRecipe"
ReferenceType=
"Microsoft.Practices.RecipeFramework.Library.AssetReferences.UnboundReferences.CSharpProjectRecipeReference,
Microsoft.Practices.RecipeFramework.Library" />
</Actions>
</Recipe>
Das Rezept "HelloWorldSimpleRecipe" (Zeile 15) wird an alle C# Projekt Ordner als Kontextmenü gebunden. Um ein Rezept zu binden gibt es zwei Möglichkeiten. Bound=true oder Bound=false. Wird Bound auf true gesetzt so ist das Rezept meist Bestandteil eines Projekttemplates oder eines speziellen Items das als Template zur Verfügung gestellt wird. Das Rezept ist dann auch nur an dieser Art von Template verfügbar. Ist Bound auf false gesetzt so wird das Rezept mittels eines Refernztypen aufgelöst. Ein solcher Referenztyp ist auf Zeile 17 deklariert. Das Rezept HelloWorldSimpleRecipe wird an das Kontextmenü eines C# Projektes gebunden.
Ein Blick auf das HelloWorldSimpleRecipe zeigt das genau eine Aktion enthalten ist.
<?xml version="1.0" encoding="utf-8" ?>
<Recipe xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
Name="HelloWorldSimpleRecipe"
xmlns="http://schemas.microsoft.com/pag/gax-core"
Bound="false">
<DocumentationLinks>
<Link Caption="Explain me what Hello World is"
Url="documentation\helloworld.htm"
Kind="Documentation"/>
</DocumentationLinks>
<xi:include href="Common\TypeAlias.xml" xmlns:xi="http://www.w3.org/2001/XInclude" />
<Caption>Demo Hello World...</Caption>
<HostData>
<CommandBar Name="Project"/>
</HostData>
<Actions>
<Action Name="HelloWorldAction"
Type="Microsoft.Germany.Sample.Actions.HelloWorldAction, MyFactory">
</Action>
</Actions>
</Recipe>
Die Aktion HelloWorldAction wird ausgeführt sobald der Kontextmenü Eintrag ausgewählt wurde. Die Implementierung ist ebenso einfach.
using System;
using System.Windows.Forms;
using Microsoft.Practices.RecipeFramework;
namespace Microsoft.Germany.Sample.Actions
{
public class HelloWorldAction : Action
{
public override void Execute()
{
MessageBox.Show( "Hello, world.",
"Another complicated Hello World demo",
MessageBoxButtons.OK );
}
public override void Undo()
{
throw new Exception( "The method or operation is not implemented." );
}
}
}
Die Undo Methode habe ich nicht implementiert. Das Projekt sieht nun sehr übersichtlich aus, hier nochmal der Auszug aus dem Solutionexplorer:

Die TypeAlias.xml ist im Verzeichnis Common hinterlegt (Nicht zu sehen im Screenshot).
Nach dem kompilieren wird das Package noch registriert. Bei der Registrierung treten in der Regel die meisten Fehler auf wenn man anfängt mit dem Guidance Automation Toolkit zu arbeiten. Wichtig ist einfach nur zu beachten das die eigentliche Fehlermeldung in einem gesonderten Output Fenster angezeigt wird.

In einer neuen Visual Studio 2005 Instanz teste ich das Package. Hierzu muß beachtet werden das es nicht unter den Projekttemplates auftaucht. Da es keinerlei Projekt- oder Solutiontemplates beinhaltet wird kann man es auch nicht als Basis für ein Projekt nehmen. Das Package wird über den Guidance Package Manager in einer kleinen Console Application hinzugefügt.

Danach wählt man "Enable/Disable Packages..." aus.

Nun selektiere ich das MyFactory Package.

Im Guidance Navigator sieht man nun die Einführende Beschreibung des Packages und im Kontextmenü taucht auch dementsprechend das Rezept auf.

Das wars für diesen Teil. Das MyFactory Projekt stellt nun das Grundgerüst dar um die Factory auszubauen und die entsprechende Funktionalität zu implementieren.
Im nächsten Teil werden näher auf das Binden von Rezepten eingehen und auch schauen welche Einschränkungen das momentane Release des Guidance Automation Toolkit hat.