Asynchrony in C# 5, Part Three: Composition

Asynchrony in C# 5, Part Three: Composition

Rate This
  • Comments 51

I was walking to my bus the other morning at about 6:45 AM. Just as I was about to turn onto 45th street, a young man, shirtless, covered in blood ran down 45th at considerable speed right in front of me. Behind him was another fellow, wielding a baseball bat. My initial thought was "holy goodness, I have to call the police right now!"

Then I saw that the guy with the baseball bat was himself being chased by Count Dracula, a small horde of zombies, a band of pirates, one medieval knight, and bringing up the rear, a giant bumblebee. Apparently some Wallingford jogging club got into the Hallowe'en spirit this past weekend.

In unrelated news: we've had lots of great comments and feedback on the async feature so far; please keep it coming. It is being read; it will take weeks to digest it and volume of correspondence may preclude personal replies, for which I apologize, but that's how it goes.

Today I want to talk a bit about composition of asynchronous code, why it is difficult in CPS, and how it is much easier with "await" in C# 5.

I need a name for this thing. We named LINQ because it was Language Integrated Query. For now, let's provisionally call this new feature TAP, the Task Asynchrony Pattern. I'm sure we'll come up with a better name later; remember, this is still just a prototype. (*)

The example I've been using so far, of fetching and archiving documents was obviously deliberately contrived to be a simple orchestration of two asynchronous tasks in a void returning method. As we saw, when using regular Continuation Passing Style it can be tricky to orchestrate even two asynchronous methods. Today I want to talk a bit about composition of asynchronous methods. Our ArchiveDocuments method was void returning, which simplifies things greatly. Suppose that ArchiveDocuments was to return a value, say, the total number of bytes archived. Synchronously, that's straightforward:

long ArchiveDocuments(List<Url> urls)
{
    long count = 0;
    for(int i = 0; i < urls.Count; ++i)
    {
        var document = Fetch(urls[i]);
        count += document.Length;
        Archive(document);
    }
    return count;
}

Now consider how we'd rewrite that asynchronously. If ArchiveDocuments is going to return immediately when the first FetchAsync starts up, and is only going to be resumed when the first fetch completes, then when is the "return count;" going to be executed? The naive asynchronous version of ArchiveDocuments cannot return a count; it has to be written in CPS too:

void ArchiveDocumentsAsync(List<Url> urls, Action<long> continuation)
{
  // somehow do the archiving asynchronously,
  // then call the continuation
}

And now the taint has spread. Now the caller of ArchiveDocumentsAsync needs to be written in CPS, so that its continuation can be passed in. What if it in turn returns a result? This is going to become a mess; soon the entire program will be written upside down and inside out.

In the TAP model, instead we'd say that the type that represents asynchronous work that produces a result later is a Task<T>. In C# 5 you can simply say:

async Task<long> ArchiveDocumentsAsync(List<Url> urls)
{
  long count = 0;
  Task archive = null;
  for(int i = 0; i < urls.Count; ++i)
  {
    var document = await FetchAsync(urls[i]);
    count += document.Length;
    if (archive != null)
      await archive;
    archive = ArchiveAsync(document);
  }
  return count;
}

and the compiler will take care of all the rewrites for you. It is instructive to understand exactly what happens here. This will get expanded into something like:

Task<long> ArchiveDocuments(List<Url> urls)
{
  var taskBuilder = AsyncMethodBuilder<long>.Create();
  State state = State.Start;
  TaskAwaiter<Document> fetchAwaiter = null;
  TaskAwaiter archiveAwaiter = null;
  int i;
  long count = 0;
  Task archive = null;
  Document document;
  Action archiveDocuments = () =>
  {
    switch(state)
    {
      case State.Start:        goto Start;
      case State.AfterFetch:   goto AfterFetch;
      case State.AfterArchive: goto AfterArchive;
    }
    Start:
    for(i = 0; i < urls.Count; ++i)
    {
      fetchAwaiter = FetchAsync(urls[i]).GetAwaiter();
      state = State.AfterFetch;
      if (fetchAwaiter.BeginAwait(archiveDocuments))
        return;
      AfterFetch:
      document = fetchAwaiter.EndAwait();
      count += document.Length;
      if (archive != null)
      {
        archiveAwaiter = archive.GetAwaiter();
        state = State.AfterArchive;
        if (archiveAwaiter.BeginAwait(archiveDocuments))
          return;
        AfterArchive:
        archiveAwaiter.EndAwait();
      }
      archive = ArchiveAsync(document);
    }
    taskBuilder.SetResult(count);
    return;
  };
  archiveDocuments();
  return taskBuilder.Task;
}

(Note that we still have problems with the labels being out of scope. Remember, the compiler doesn't need to follow the rules of C# source code when it is generating code on your behalf; pretend the labels are in scope at the point of the goto. And note that we still have no exception handling in here. As I discussed last week in my post on building exception handling in CPS, exceptions get a little bit weird because there are *two* continuations: the normal continuation and the error continuation. How do we deal with that situation? I'll discuss how exception handling works in TAP at a later date.)

Let me make sure the control flow is clear here. Let's first consider the trivial case: the list is empty. What happens?  We create a task builder. We create a void-returning delegate. We invoke the delegate synchronously. It initializes the outer variable "count" to zero, branches to the "Start" label, skips the loop, tells the helper "you have a result", and returns. The delegate is now done. The taskbuilder is asked for a task; it knows that the task's work is completed, so it returns a completed task that simply represents the number zero.

If the caller attempts to await that task then its awaiter will return false when asked to begin async operations, because the task has completed. If the caller does not await that task then... well, then they do whatever they do with a Task. Eventually they can ask it for its result, or ignore it if they don't care.

Now let's consider the non-trivial case; there are multiple documents to archive. Again, we create a task builder and a delegate which is invoked synchronously. First time through the loop, we begin an asynchronous fetch, sign up the delegate as its continuation, and return from the delegate. At that point the task builder builds a task that represents "I'm asynchronously working on the body of ArchiveDocumentsAsync" and returns that task. When the fetch task completes asynchronously and invokes its continuation, the delegate starts up again "from the point where it left off" thanks to the magic of the state machine. Everything proceeds exactly as before, in the case of the void returning version; the only difference is that the returned Task<long> for ArchiveDocumentsAsync signals that it is complete (by invoking its continuation) when the delegate tells the task builder to set the result.

Make sense?

Before I continue with some additional thoughts on composition of tasks, a quick note on the extensibility of TAP. We designed LINQ to be very extensible; any type that implements Select, Where, and so on, or has extension methods implemented for them, can be used in query comprehensions. Similarly with TAP: any type that has a GetAwaiter that returns a type that has BeginAwait, EndAwait, and so on, can be used in "await" expressions. However, methods marked as being async can only return void, Task, or Task<T> for some T. We are all about enabling extensibility on consumption of existing asynchronous things, but have no desire to get in the business of enabling production of asynchronous methods with exotic types. (The alert reader will have noted that I have not discussed extensibility points for the task builder. At a later date I'll discuss where the task builder comes from.)

Continuing on: (ha ha ha)

In LINQ there are some situations in which the use of "language" features like "where" clauses is more natural and some where using "fluent" syntax ("Where(c=>...)") is more natural. Similarly with TAP: our goal is to enable use of regular C# syntax to compose and orchestrate asynchronous tasks, but sometimes you want to have a more "combinator" based approach. To that end, we'll be making available methods with names like like "WhenAll" or "WhenAny" that compose tasks like this:

    List<List<Url>> groupsOfUrls = whatever;
    Task<long[]> allResults = Task.WhenAll(from urls in groupsOfUrls select ArchiveDocumentsAsync(urls));
    long[] results = await allResults;

What does this do? Well, ArchiveDocumentsAsync returns a Task<long>, so the query returns an IEnumerable<Task<long>>. WhenAll takes a sequence of tasks and produces a new task which asynchronously awaits each of them, fills the result into an array, and then invokes its continuation with the results when available.

Similarly we'll have a WhenAny that takes a sequence of tasks and produces a new task that invokes its continuation with the first result when any of those tasks complete. (An interesting question is what happens if the first one completes successfully and the rest all throw an exception, but we'll talk about that later.)

There will be other task combinators and related helper methods; see the CTP samples for some examples. Note that in the CTP release we were unable to modify the existing Task class; instead we've provisionally added the new combinators to TaskEx. In the final release they will almost certainly be moved onto Task.

Next time: No, seriously, asynchrony does not necessarily involve multithreading.

(*) I emphasize that this is provisional and for my own rhetorical purposes, and not an official name of anything. Please don't publish a book called "Essential TAP" or "Learn TAP in 21 Time Units" or whatever. I have a copy of "Instant DHTML Scriptlets" on my bookshelf; Dino Esposito writes so fast that he published an entire book between the time we mentioned the code name of the product to him and we announced the real name. ("Windows Script Components" was the final name.)

  • @Daniel:  recompilation absolutely is a show stopper for a lot of people.  Not me -- I don't spend $100k certifying a piece of software to meet government standards -- but for a lot of other people it is.

    Were we discussing a proposed feature for C#1, I don't think there's be as much of an issue, because we could (rightly) expect no legacy code to support.

    But back to 'start'.  I do not believe that the most-used operation is actually the fetching of the result.  It's the composition of the task.  Given that, the invocation marker needs to be at the end, not the beginning.  That is, by default you get the composition unit, not the evaluation result.

    We see this same pattern with LINQ as it's typically implemented:  we favor composition, and provide (pre-existing, in this case) sugar to call GetEnumerator().

  • I'd really like to see an async foreach; one of the frequent samples is using a for-loop to demonstrate the power of async/await. But what about a foreach that streams its results in an async fashion?

    interface IAsyncEnumerator : IEnumerator, IDisposable

    {

       async bool MoveNextAsync();

    }

    Then the following code

    foreach async (T elem in asyncColl)

    {

       ...

    }

    could be translated to

    using (IAsyncEnumerator e = (IAsyncEnumerator) asyncColl.GetEnumerator())

    {

       while (await e.MoveNextAsync())

       {

           T elem = e.Current;

           ...

       }

    }

    Now, that would also suggest supporting a syntax to create such IAsyncEnumerators through the existing iterator support. A yield async x...? Or explicitly returning an IAsyncEnumerable<T>/IAsyncEnumerator<T> rather than an IEnumerable<T>/Enumerator<T>?

    That would be truly awsome.

  • @Daniel: "You have to think of async methods as an alternative implementation of the concept of a method. They add a certain extra valuable capability: they can be started, as well as merely called. But when you're merely calling them, they're the same concept, and so the same notation would be ideal."

    I think that's the whole reason why I don't like "await" as a keyword. Because, if I'm understanding this series of posts correctly, "merely calling them" (and awaiting the result) is precisely what you're *not* doing. You're starting them and then specifying what will happen after they are complete. An "await" doesn't signify a blocking call to a method. It's similar to one, but it's not quite the same semantics. So I'm not in favor of the difference between them being elided entirely.

    Also, if I understand rightly, "await" can only be used inside an async method. If you made "await" unnecessary and implied, then you'd have methods that could (effectively) only be called from async methods, without any clear syntactic reason why.

    (Point taken about await not being the opposite of start)

  • Can you please explain a little bit why you only target async operations by this pattern?

    For me all these continuations, etc. looks like an "async" monad in F# ported into C#, and because there is no such syntax in C#, you have to introduce two new keywords.

    in F# world it is:

    let MyFunction =

       async {

           ...

           let! value = GetAsyncValue();

           ...

       }

    So the question is, why do not introduce keywords that allow us to deal with any monad, not just async?

    the "async" modifier become just a name of the monad, and "await" is nothing more than "let!", which represents the "Bind" operation, isn't it?

    It would be really interesting to know your thoughts about it.

  • @Stuart:

    > Because, if I'm understanding this series of posts correctly, "merely calling them" (and awaiting the result) is precisely what you're *not* doing. You're starting them and then specifying what will happen after they are complete. An "await" doesn't signify a blocking call to a method.

    Although 'await' in front of a method invocation doesn't mean "blocking" at the CLR level, it does mean "put in the necessary plumbing to resume when we have the logical return value of the method we're invoking" - and that's the return value that would be obtained when the called method reaches a return statement (if that method is also an async C# method). This is really the same thing that the CLR does with its built-in implementation of stacks, method calls and threads. It's just implemented differently, giving us greater control over the way our methods execute, instead of them being tied to threads and stacks.

    In C# today, when a method calls another method, what happens? The execution of the calling method is paused, the called method begins executing. When the called method finishes executing, the execution of the calling method is resumed and the return value of the called method is available. That's what a method call means.

    > Also, if I understand rightly, "await" can only be used inside an async method. If you made "await" unnecessary and implied, then you'd have methods that could (effectively) only be called from async methods, without any clear syntactic reason why.'

    I mention that on the programmers.stackexchange answer I linked to previously. The compiler could simply behave exactly as it does today outside of async methods. Nothing would be taken away at all. However, I think it might be worth requiring the caller to put the 'start' prefix in front of a call to an [AutoAwait] method when the call is not in an async method. It has the virtue of making code retain the same meaning when it is copied and pasted between async and non-async methods.

  • I'm surprised that the last ArchiveAsync operation (in ArchiveDocumentsAsync) isn't awaited; I would have expected to see "if (archive != null) await archive;" right before "return count;". I know that it *can* run in parallel with the total count of bytes being returned to the caller (so ArchiveDocumentsAsync doesn't *need* to await it), but it certainly feels odd that the caller has no way to catch an exception thrown by that last ArchiveAsync call, and has no guarantees that the archiving has actually finished.

    Or maybe this is just contrived sample code and I shouldn't be too picky about the style...

  • Is cancellation supported with TaskEx.Run method?

    Consider the following code:

       public partial class MainWindow : Window

       {

           public MainWindow()

           {

               InitializeComponent();

           }

           private CancellationTokenSource cancelationRoute;

           private async void Button_Click(object sender, RoutedEventArgs e)

           {

               var btn = sender as Button;

               if(btn.Name=="btnDoWork")

               {

                   btnDoWork.IsEnabled = false;

                   lblResult.Content = string.Empty;

                   await DoWork();

               }

               else if(btn.Name == "btnCancel")

               {

                   cancelationRoute.Cancel();

               }

           }

           private async Task DoWork()

           {

               Task<string> task;

              try

              {

                  cancelationRoute = new CancellationTokenSource();

                  task = TaskEx.Run<string>(CopyFile, cancelationRoute.Token);

                  await task;

                  lblResult.Content = task.Status.ToString();

                  btnDoWork.IsEnabled = true;

              }

              catch(OperationCanceledException)

              {

                  lblResult.Content = "canceled";

                  btnDoWork.IsEnabled = true;

                  return;

              }

              cancelationRoute = null;

           }

           private string CopyFile()

           {

               Enumerable.Repeat(100, 50).ToList().ForEach(Thread.Sleep);

               return "Ok, I finished!";

           }

       }

    }

    This is code-behind of simple UI consists of two buttons "Do Work" and "Cancel" and result label.

    If I click Do Work button, everything is fine - the UI is responsive and 5 seconds later the result label shows "RanToCompletion" status.

    But cancellation does not work. Even though I click Cancel which calls to cancelationRoute.Cancel() while the task is run, the task ends up with RanToCompletion status.

    Am I doing something wrong?

  • Hi,

     Sorry for off topic :*)

     I see that you are stick with the new aynch feature for a while, but I have a struct related question I eager to have an answer to and google is unable to help me. I hope you will give me a good link at least. Please!

     I'm trying to get what I call measurement units system by wrapping double into struct. I have C# structures Meter, Second, Degree, etc. My original idea was that after compiler has inlined everything I would have a performance the same as if double were used.

     My explicit and implicit operators are simple and straightforward, and compiler does actually inline them, yet the code with Meter and Second is 10 times slower than the same code using double.

     My question is being: why cannot C# compiler make the code using Second as optimal as the code using double if it inlines everything anyway?

      Second is defined as following:

    struct Second

    {

      double _value; // no more fields.

      Second operator + (Second left, Second right) { return left._value + right._value; }

      // plenty of simple operators

    }

  • @Ilya: I suggest you ask on Stack Overflow instead - it's not really relevant here.

  • Eric,

    Looks nice.  Does this mean that Silverlight and Phone7 are finally going to get access to the task parallel library?

  • Any comments on my earlier post of using Attributes for Asynch work?

  • I've got the answer in another cool blog:

    blogs.msdn.com/.../a-technical-walk-through-all-of-the-async-ctp.aspx

  • @Alexey "So the question is, why do not introduce keywords that allow us to deal with any monad, not just async?"

    Because that already exists: the LINQ syntax allows you to do exactly that.

  • @Daniel - "In C# today, when a method calls another method, what happens? The execution of the calling method is paused, the called method begins executing. When the called method finishes executing, the execution of the calling method is resumed and the return value of the called method is available. That's what a method call means."

    It's taken a few days for this concept to sink in properly but I see what you're saying now. Sorry that it took me so long. I was so busy trying to turn myself inside out to understand CPS that I forgot to turn myself right-side out again afterwards ;)

    Perhaps the appropriate keyword, then, isn't something that talks explicitly about control flow, like "continue after" or whatever, OR something that implies asynchrony like "await", but something that just says "do the whole of" or "fully execute" or "complete".

    var document = complete FetchAsync(url);

    var document = finish FetchAsync(url);

    var document = do FetchAsync(url);

    var document = invoke FetchAsync(url);

    I think I like "finish" best of these, because then you get:

    if (archive != null) finish archive;

    Plus there's a lovely symmetry with:

    var archive = start ArchiveAsync(document);

    The more I think about this whole thing, the more it worries me that you can only effectively call async methods (in the most natural way) from within other async methods. That's going to make interoperability with non-async code a nightmare - especially where you have to implement an interface that expects a return value. It seems like the "async" modifier might become viral, increasingly needing to be applied to more and more methods because they want to call other async methods, until you can't do anything useful without it. (If I'm right about that, it means that the limitation that you can't write an async iterator method may be a bigger problem than it appears at first glance...)

    I wonder if there'd be some value in having at least partial support for the "finish" keyword in non-async methods (perhaps only when applied directly to a method invocation, not to an existing Task?), but implemented by use of a library method that invokes the task on a separate thread and blocks until it completes.

  • Stuart: You are correct that "await" (or "finish" as you'd have it) is contagious. Anything that uses it must be async, causing all of its callers to be async, and so on. So how do you get a Task's result from a non-async method? You just get the Task.Result property (or call Task.Wait() for void methods), which is just what you'd do in C# 4 because it only has non-async methods.

    So with the CTP you can write:

    var document = await FetchAsync(urls[i]);

    to get the URL while other stuff executes on the thread, or you can write:

    var document = FetchAsync(urls[i]).Result;

    and the thread will sit there waiting until the URL is fetched.

Page 3 of 4 (51 items) 1234