C# in Depth

Summary181(without using a dedicated thread) until it had completed, calling the supplied delegateto handle the result. It would then call MoveNext again, and our method wouldcontinue. This time we kick off two requests in parallel, and the CCR to call another delegatewith the results of both operations when they’ve both finished. After that, Move-Next is called for a final time and we get to complete the request processing.Although it’s obviously more complicated than the synchronous version, it’s still allin one method, it will get executed in the order written, and the method itself canhold the state (in the local variables, which become state in the extra type generatedby the compiler). It’s fully asynchronous, using as few threads as it can get away with. Ihaven’t shown any error handling, but that’s also available in a sensible fashion thatforces you to think about the issue at appropriate places.It all takes a while to get your head around (at least unless you’ve seen continuationpassingstyle code before) but the potential benefits in terms of writing correct, scalablecode are enormous—and it’s only feasible in such a neat way due to C# 2’s syntacticsugar around iterators and anonymous methods. The CCR hasn’t hit the mainstream atthe time of writing, but it’s possible that it will become another normal part of thedevelopment toolkit 11 —and that other novel uses for iterator blocks will be thought upover time. As I said earlier, the point of the section is to open your mind to possible usesof the work that the compiler can do for you beyond just simple iteration.6.5 SummaryC# supports many patterns indirectly, in terms of it being feasible to implement themin C#. However, relatively few patterns are directly supported in terms of language featuresbeing specifically targeted at a particular pattern. In C# 1, the iterator patternwas directly supported from the point of view of the calling code, but not from theperspective of the collection being iterated over. Writing a correct implementation ofIEnumerable was time-consuming and error-prone, without being interesting. In C# 2the compiler does all the mundane work for you, building a state machine to copewith the “call-back” nature of iterators.It should be noted that iterator blocks have one aspect in common with the anonymousmethods we saw in chapter 5, even though the actual features are very different.In both cases, extra types may be generated, and a potentially complicated code transformationis applied to the original source. Compare this with C# 1 where most of thetransformations for syntactic sugar (lock, using, and foreach being the most obviousexamples) were quite straightforward. We’ll see this trend toward smarter compilationcontinuing with almost every aspect of C# 3.As well as seeing a real-life example of the use of iterators, we’ve taken a look athow one particular library has used them in a fairly radical way that has little to dowith what comes to mind when we think about iteration over a collection. It’s worthbearing in mind that different languages have also looked at this sort of problem11 Some aspects of the CCR may also become available as part of the Parallel Extensions library described inchapter 13.Licensed to Rhona Hadida