b2aat6n
b2aat6n
b2aat6n
Erfolgreiche ePaper selbst erstellen
Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.
Testdaten automatisch generieren<br />
Tückisches GUI<br />
A<br />
uch bei dieser Aufgabe zeigte<br />
sich wieder, wie wichtig es<br />
ist, sich vor der Implementierung<br />
ein paar Gedanken zur<br />
Architektur zu machen. Der erste Gedanke,<br />
das Erzeugen der Daten vom Speichern zu<br />
trennen, liegt auf der Hand und wurde in<br />
der Aufgabenstellung schon erwähnt.<br />
Doch wie geht man generell vor, wenn für<br />
eine Aufgabenstellung eine Architektur<br />
entworfen werden soll? Ganz einfach: Man<br />
malt den „kleinen König“. Den gibt es immer,<br />
denn er ist schließlich derjenige, der<br />
die Anforderungen formuliert hat. Er ist<br />
der Grund dafür, dass das System überhaupt<br />
gebaut wird. Das zu implementierende<br />
System als Ganzes kann man auch<br />
sofort hinmalen. Damit liegt man nie verkehrt.<br />
Es ergibt sich damit das in Abbildung<br />
1 gezeigte Bild.<br />
Das Diagramm nennt sich System-Umwelt-Diagramm,<br />
da es das System in seiner<br />
Umwelt zeigt. In der Umwelt des Systems<br />
gibt es immer mindestens einen Client, den<br />
kleinen König, der das System bedient. Bei<br />
manchen Systemen mag es mehrere unterschiedliche<br />
Clients geben, das spielt für den<br />
Testdatengenerator jedoch keine Rolle. Die<br />
zweite Kategorie von Elementen in der Umwelt<br />
stellen Ressourcen dar. Diese liegen<br />
außerhalb des zu erstellenden Systems und<br />
sollten daher in das System-Umwelt-Diagramm<br />
aufgenommen werden, denn unser<br />
System ist von diesen Ressourcen abhän-<br />
gig. Im Fall des Testdatengenerators sind<br />
als Ressourcen in der Umwelt CSV-Dateien<br />
und Datenbanken denkbar. Irgendwo müssen<br />
die generierten Testdaten schließlich<br />
hin. Folglich ergänze ich das System-Umwelt-Diagramm<br />
um diese Ressourcen. Das<br />
Ergebnis ist in Abbildung 2 zu sehen.<br />
Wer nun glaubt, ein solches Diagramm<br />
sei ein Taschenspielertrick, um Zeit zu<br />
schinden, ohne Nutzen für den Architekturentwurf,<br />
der irrt. Denn aus diesem Bild<br />
wird bereits deutlich, welche Komponenten<br />
mindestens entstehen müssen. Den<br />
Begriff Komponente verwende ich hier mit<br />
einer festen Bedeutung, siehe dazu die Erläuterungen<br />
im Kasten.<br />
Der Kern des Systems sollte gegenüber<br />
der Umwelt abgeschirmt werden, weil das<br />
System die Umwelt nicht kontrollieren kann.<br />
Die Umwelt kann sich verändern. Es können<br />
etwa neue Clients hinzukommen oder<br />
auch zusätzliche Ressourcen. Folglich müssen<br />
auf der Umrandung des Systems Komponenten<br />
entstehen, die den Kern des Systems<br />
über definierte Schnittstellen gegenüber<br />
der Umwelt isolieren. Andernfalls würde<br />
der Kern des Systems immer wieder von<br />
Änderungen in der Umwelt betroffen sein<br />
und wäre damit sehr anfällig. Und darin<br />
liegt die Bedeutung des System-Umwelt-<br />
Diagramms: Es zeigt, welche Komponenten<br />
das System von der Umwelt abschirmen.<br />
Für Clients, die das System verwenden,<br />
bezeichnen wir die Komponente, über wel-<br />
LÖSUNG<br />
Bei dieser Übung ging der Kern der Anwendung relativ leicht von der Hand. Die eigentliche Herausforderung lag in der<br />
dynamischen Benutzerschnittstelle. Jeder Datentyp verlangt andere Oberflächenelemente. Und der Anwender will<br />
seine Daten individuell strukturieren können.<br />
Komponente<br />
Eine Komponente ist eine binäre Funktionseinheit mit separatem Kontrakt:<br />
Binär bedeutet hier, dass die Komponente an den Verwendungsstellen binär referenziert wird. Es<br />
wird also bei der Verwendung keine Referenz auf das entsprechende Visual-Studio-Projekt gesetzt,<br />
sondern eine Referenz auf die erzeugte Assembly.<br />
Separater Kontrakt bedeutet, dass das Interface für die Komponente in einer eigenen Assembly<br />
abgelegt ist und nicht in der Assembly liegt, in welcher die Komponente implementiert ist. Daraus<br />
folgt, dass eine Komponente immer aus mindestens zwei Assemblies besteht, nämlich einer für den<br />
Kontrakt und einer für die Implementierung. Und natürlich gehören Tests dazu – also besteht jede<br />
Komponente aus mindestens drei Projekten.<br />
[Abb. 1] System-<br />
Umwelt-<br />
Diagramm,<br />
Version 1.<br />
[Abb. 2] System-Umwelt-Diagramm, Version 2.<br />
che der Client mit dem System interagiert,<br />
als Portal. In Abhängigkeitsdiagrammen<br />
werden Portale immer als Quadrate dargestellt.<br />
Die Interaktion des Systems mit Ressourcen<br />
erfolgt über Adapter. Diese werden<br />
durch Dreiecke symbolisiert. Im konkreten<br />
Fall des Testdatengenerators können wir<br />
aufgrund des System-Umwelt-Diagramms<br />
also schon vier Komponenten identifizieren,<br />
siehe Abbildung 3:<br />
❚ Portal,<br />
❚ CSV-Adapter,<br />
❚ Datenbank-Adapter,<br />
❚ Testdatengenerator.<br />
Die Komponenten sollten normalerweise<br />
allerdings nicht im System-Umwelt-Diagramm<br />
eingezeichnet werden, weil dort<br />
sonst zwei Belange vermischt werden. Es<br />
soll hier nur gezeigt werden, dass sich Portal<br />
und Adapter immer sofort aus dem System-Umwelt-Diagramm<br />
ergeben. Aus dem<br />
in Abbildung 3 gezeigten Diagramm lässt<br />
sich das in Abbildung 4 gezeigte Abhängigkeitsdiagramm<br />
ableiten.<br />
Den Kern zerlegen<br />
Nachdem ich diese Komponenten identifiziert<br />
hatte, habe ich die Aufgabenstellung<br />
www.dotnetpro.de dotnetpro.dojos.2011 15