15.02.2013 Aufrufe

b2aat6n

b2aat6n

b2aat6n

MEHR ANZEIGEN
WENIGER ANZEIGEN

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

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!