b2aat6n

Listing 2
Rückgabedaten vom Typ IEnumerable nutzen.
public void Flow() {
var input = Input();
var x1 = A(input);
var x2 = B(x1);
var result = C(x2);
}
foreach(var value in result) {
...
}
public IEnumerable Input() {
yield return "Äpfel";
yield return "Birnen";
yield return "Pflaumen";
}
public IEnumerable A(IEnumerable input) {
foreach (var value in input) {
yield return string.Format("({0})", value);
}
}
public IEnumerable B(IEnumerable input) {
foreach (var value in input) {
yield return string.Format("[{0}]", value);
}
}
public IEnumerable C(IEnumerable input) {
foreach (var value in input) {
yield return string.Format("-{0}-", value);
}
}
Listing 3
Die Stages syntaktisch koppeln.
public static IEnumerable A(this IEnumerable input) {
foreach (var value in input) {
yield return string.Format("({0})", value);
}
}
...
var result = Input().A().B().C();
dieser Tests ist eine Action, die auf
einer Instanz der Klasse ausgeführt wird,
die zu testen ist. Wenn also die Klasse KundeViewModel
überprüft werden soll, wird
für jede Property eine Action erzeugt. Sind die Actions erzeugt,
müssen sie nur nach ein ander ausgeführt
werden. Dabei soll jede Action eine neue
Instanz der zu testenden Klasse erhalten.
Andernfalls könnte es zu Seiteneffekten
beim Testen der Properties kommen.
Funktionseinheiten identifizieren
Die erste Aufgabe ist also das Ermitteln der
zu testenden Properties. Eingangspara -
meter in diese Funktionseinheit ist der Typ,
für den die INotifyPropertyChanged-Implementierung
überprüft werden soll. Das Ergebnis
der Flowstage ist eine Aufzählung
der Property-Namen.
static IEnumerable
FindPropertyNames(this Type type)
LÖSUNG
An dieser Stelle fragen Sie sich möglicherweise,
warum ich die Property-Namen
als Strings zurückgebe und nicht etwa eine
Liste von PropertyInfo-Objekten. Schließlich
stecken in PropertyInfo mehr Informationen,
insbesondere der Typ der Property,
den ich später ebenfalls benötige. Ich habe
mich dagegen entschieden, weil dies das
Testen der nächsten Flowstage deutlich
erschwert hätte. Denn diese hätte dann auf
einer Liste von PropertyInfo-Objekten arbeiten
müssen. Und da PropertyInfo-Instanzen
nicht einfach mit new hergestellt werden
können, wären die Tests recht mühsam geworden.
Nachdem die Property-Namen bekannt
sind, kann die nächste Flowstage dazu den
jeweiligen Typ ermitteln. Die Flowstage erhält
also eine Liste von Property-Namen
sowie den Typ und liefert eine Aufzählung
von Typen.
static IEnumerable FindPropertyTypes(
this IEnumerable propertyNames,
Type type)
Im Anschluss muss für jeden Typ ein Objekt
instanziert werden. Diese Objekte werden
später im Test den Properties zuge -
wiesen. Die Flowstage erhält also eine Liste
von Typen und liefert für jeden dieser Typen
eine Instanz des entsprechenden Typs.
static IEnumerable GenerateValues(
this IEnumerable types)
Dann wird es spannend: Die Actions
müssen erzeugt werden. Dabei lässt es sich
leider nicht vermeiden, die Property-Namen
aus der ersten Stage nochmals zu verwenden.
Die Ergebnisse der ersten Stage
fließen also nicht nur in die unmittelbar
nächste Stage, sondern zusätzlich auch
noch in die Stage, welche die Actions erzeugt.
Die Namen der Properties werden
benötigt, um mittels Reflection die jeweiligen
Setter aufrufen zu können.
static IEnumerable
GenerateTestMethods(this IEnumerable
values, IEnumerable propertyNames,
Type type)
Der letzte Schritt besteht darin, die gelieferten
Actions auszuführen. Dazu muss jeweils
eine Instanz der zu testenden Klasse erzeugt
und an die Action übergeben werden.
Abbildung 2 zeigt den gesamten Flow.
Die einzelnen Flowstages sind als Extension
Method implementiert. Der Flow selbst
wird in der öffentlichen Methode NotificationTester.Verify
zusammengesteckt. Testen
www.dotnetpro.de dotnetpro.dojos.2011 11