Question

Some APIs, like the WebClient, use the Event-based Async pattern. While this looks simple, and probably works well in a loosely coupled app (say, BackgroundWorker in a UI), it doesn’t chain together very well.

For instance, here’s a program that’s multithreaded so the async work doesn’t block. (Imagine this is going in a server app and called hundreds of times — you don’t want to block your ThreadPool threads.) We get 3 local variables (‘state’), then make 2 async calls, with the result of the first feeding into the second request (so they can’t go parallel). State could mutate too (easy to add).

Using WebClient, things end up like the following (or you end up creating a bunch of objects to act like closures):

using System; using System.Net;  class Program {     static void onEx(Exception ex) {         Console.WriteLine(ex.ToString());     }      static void Main() {         var url1 = new Uri(Console.ReadLine());         var url2 = new Uri(Console.ReadLine());         var someData = Console.ReadLine();          var webThingy = new WebClient();         DownloadDataCompletedEventHandler first = null;         webThingy.DownloadDataCompleted += first = (o, res1) => {             if (res1.Error != null) {                 onEx(res1.Error);                 return;             }             webThingy.DownloadDataCompleted -= first;             webThingy.DownloadDataCompleted += (o2, res2) => {                 if (res2.Error != null) {                     onEx(res2.Error);                     return;                 }                 try {                     Console.WriteLine(someData + res2.Result);                 } catch (Exception ex) { onEx(ex); }             };             try {                 webThingy.DownloadDataAsync(new Uri(url2.ToString() + '?data=' + res1.Result));             } catch (Exception ex) { onEx(ex); }         };         try {             webThingy.DownloadDataAsync(url1);         } catch (Exception ex) { onEx(ex); }          Console.WriteLine('Keeping process alive');         Console.ReadLine();     } 

}

Is there an generic way to refactor this event-based async pattern? (I.e. not have to write detailed extension methods for each API thats like this?) BeginXXX and EndXXX make it easy, but this event way doesn’t seem to offer any way.

Answer 1

You might want to look into F#. F# can automate this coding for you with its «workflow» feature. The ’08 PDC presentation of F# dealt with asynchronous web requests using a standard library workflow called async, which handles the BeginXXX/EndXXX pattern, but you can write a workflow for the event pattern without much difficulty, or find a canned one. And F# works well with C#.