den Event auf einem anderen Thread auszulösen, muss ein neuer Thread gestartet werden. Das kann dadurch erfolgen, dass Sie eine neue Instanz eines Threads anlegen oder einen freien Thread aus dem ThreadPool verwenden. Dabei kann eine Lambda-Expression übergeben werden, die auf dem neuen Thread ausgeführt wird. Wenn man einen neuen Thread anlegt, muss das Starten des Threads explizit durch Start erfolgen, siehe Listing 2.
Listing 2
Den neuen Thread explizit starten.
public class Asynchronizer<T> { public void Process(T input) { var thread = new Thread(() => Result(input)); thread.Start(); } public event Action<T> Result; }
Ganz einfach, oder? Die erste Frage lautet nun: Wie kann man den Asynchronizer automatisiert testen? Des Weiteren stellt sich die Frage, ob es eine gute Idee ist, jeweils einen neuen Thread zu erzeugen. Würde der Zugriff auf den ThreadPool Vorteile bringen? Doch zunächst zum Testen.
Asynchronen Code testen
Die Herausforderung beim automatisierten Testen von asynchronem Code liegt darin, dass der zu testende Code im Testablauf relativ schnell zum Aufrufer zurückkehrt. Denn schließlich wird die zu erledigende Aufgabe auf einen anderen Thread in den Hintergrund verschoben. Kehrt der zu testende Code jedoch in die Testmethode zurück, wird diese bis zu ihrem Ende ausgeführt und dann beendet. Damit ist dann auch der Test schon zu Ende, bevor es richtig losging. Die Herausforderung besteht also darin, in der Testmethode auf die Ausführung des Hintergrundthreads zu warten. Wie wäre es mit Thread.Sleep()? Listing 3 zeigt ein Beispiel.
Listing 3
Nicht optimal: Thread.Sleep.
[Test] public void Naive_approach_to_async_ tests() { var result = 0; sut.Result += x => result = x; sut.Process(42); Thread.Sleep(500); Assert.That(result, Is.EqualTo(42)); }
Aber wie lange soll auf den Hintergrundthread gewartet werden? Eine halbe Sekunde, sprich 500 ms wie oben gezeigt? Meist genügt das. Doch wenn der Test auf einem gut ausgelasteten Continuous Integration Server läuft, dann kann die Wartezeit zu gering sein. Also zur Sicherheit fünf Sekunden warten? Nein, natürlich ist das keine gute Idee. Der Test soll natürlich exakt so lange auf den Hintergrundthread warten, bis dieser fertig ist. Das erreichen Sie mit einem WaitHandle, Listing 4 zeigt den entsprechenden Code. Vergessen Sie Thread. Sleep für solche Fälle.
Listing 4
Besser : WaitHandle.
[TestFixture] public class AsynchronizerTests { private EventWaitHandle waitHandle; private Asynchronizer<int> sut; [SetUp] public void Setup() { sut = new Asynchronizer<int>(); waitHandle = new EventWaitHandle( false, EventResetMode.ManualReset); } [Test] public void Result_event_is _raised_with_parameter() { var result = 0; sut.Result += x => { result = x; waitHandle.Set(); }; sut.Process(42); Assert.That(waitHandle.WaitOne(500), Is.True); Assert.That(result, Is.EqualTo(42)); } }
Das WaitHandle wird verwendet, um nach Aufruf der Process-Methode darauf zu warten, dass der Result-Event auf dem neu gestarteten Thread seine Arbeit verrichtet hat. Das WaitHandle befindet sich anfangs im Zustand „nicht gesetzt“. Wird waitHandle.WaitOne aufgerufen, wird der aktuelle Thread so lange angehalten, bis das WaitHandle gesetzt ist. Daher muss das WaitHandle im Result-Event mit Set gesetzt werden. Auf diese Weise wacht der Thread, auf dem der Test läuft, dann wieder auf und kann sein Assert ausführen.
Damit der Test bei einem Fehler nicht unendlich lange wartet, habe ich bei WaitOne einen Timeout von 500 ms definiert. Dadurch wird das WaitHandle entweder durch Set innerhalb von 500 ms gesetzt oder durch einen Timeout. Der Timeout tritt automatisch ein, wenn das WaitHandle nicht nach der hinterlegten Zeit mit Set gesetzt wird, in diesem Fall nach 500 ms. Der Timeout wird dadurch signalisiert, dass WaitOne false zurückliefert.
Um den Timeout im Test zu erkennen, habe ich ein Assert ergänzt, welches prüft, ob WaitOne mit true beendet wurde. Wenn das der Fall ist, ist das WaitHandle ordnungsgemäß mit Set gesetzt worden, sprich, der Result-Event wurde ausgelöst. Liefert WaitOne jedoch false zurück, ist im Test etwas schiefgelaufen, weil das WaitHandle durch einen Timeout ausgelöst wurde.
Hier ist es nun tatsächlich angemessen, darüber nachzudenken, ob 500 ms als Timeout ausreichend sind. Auf einem Continuous Integration Server kann das schon mal knapp bemessen sein. Da die Timeout-Zeitspanne nur dann in Anspruch genommen wird, wenn etwas schiefläuft, können Sie den Timeout nun ohne Not auf mehrere Sekunden hochsetzen. Solange alles in Ordnung ist, und das sollte der Normalfall sein, läuft der Test dann durch, so schnell es eben geht. Nur für den hoffentlich seltenen Fall, dass jemand den Code „kaputt gemacht hat“, tritt die Timeout-Wartezeit in Kraft.
ThreadPool
Alternativ zum Erzeugen eines neuen Threads kann auch ein Thread aus dem ThreadPool verwendet werden. Dies hat Vorteile bei kurzlaufenden Operationen, da der ThreadPool weniger Overhead benötigt. Die Threads sind bereits erzeugt und warten nur auf einen neuen Auftrag.
Der wichtigste Unterschied liegt jedoch darin, dass Threads aus dem ThreadPool als Hintergrundthreads laufen, während neu erzeugte Threads standardmäßig Vordergrundthreads sind. Hintergrundthreads werden automatisch beendet, sobald alle Vordergrundthreads beendet sind. In der Regel hat ein Programm lediglich einen einzigen Vordergrundthread, der die UI übernimmt. Beendet man das Programm, werden automatisch alle Hintergrundthreads mitbeendet. Die selbst erzeugten Vordergrundthreads laufen jedoch weiter, sodass das Programm in diesem Fall nicht einfach dadurch beendet wird, dass das UI geschlossen wird.
Man kann natürlich auch selbst erzeugte Threads als Hintergrundthread starten, indem vor dem Start die Eigenschaft IsBackground auf true gesetzt wird. Was man im Einzelfall benötigt, hängt vom konkreten Anwendungsfall ab.
Und wieder synchron
Mithilfe des Asynchronizer-Bausteins kann die Ausführung des im Fluss nachfolgenden Bausteins auf einen anderen Thread verlagert werden. Doch was tun, wenn die Ergebnisse aus dem Hintergrundthread in das UI übernommen werden sollen? Dann ergibt sich bei Windows Forms, WPF und Silverlight das Problem, dass die Controls nur aus dem UI-Thread heraus angesprochen werden dürfen. Die Windows-Forms-Controls haben dafür einen Mechanismus: InvokeRequired und Invoke, siehe Listing 5.
Listing 5
InvokeRequired nutzen.
if (listBox1.InvokeRequired) { listBox1.Invoke(new MethodInvoker(() => listBox1.Items.Add(t))); } else { listBox1.Items.Add(t); }
Bevor in diesem Beispiel ein weiterer Eintrag in die ListBox eingefügt wird, wird durch Abfrage von InvokeRequired geprüft, ob der Aufruf mit Invoke erfolgen muss. Ist das der Fall, wird dem Invoke-Aufruf eine Lambda-Expression übergeben, welche den Eintrag in die ListBox schreibt. Invoke sorgt dafür, dass die Lambda-Expression auf dem UI-Thread ausgeführt wird.
Das kann man so machen, doch man sollte es nicht so machen. Denn auf diese Weise wird der UI-Code mit Aspekten der Parallelisierung kontaminiert. Außerdem müsste ein UI, das zunächst synchron und erst später asynchron verwendet wird, modifiziert werden. Das ist unschön. Zum einen verstößt diese Vorgehensweise gegen das Open Closed Principle (OCP), welches besagt, dass eine Klasse offen für Erweiterungen, aber geschlossen gegenüber Modifikationen sein sollte. Noch schwerer wiegt das Argument, dass auf diese Weise das Prinzip die Separation of Concerns (SoC) verletzt würde. Der Aspekt der Parallelisierung würde mit der eigentlichen Aufgabe des UIs vermischt.
Abhilfe schafft die Verwendung des SynchronizationContext bei Windows Forms bzw. des Dispatchers bei WPF und Silverlight. Beides