How does async works in C#?

by

It works similarly to the yield return keyword in C# 2.0.

An asynchronous method is not actually an ordinary sequential method. It is compiled into a state machine (an object) with some state (local variables are turned into fields of the object). Each block of code between two uses of await is one “step” of the state machine.

This means that when the method starts, it just runs the first step and then the state machine returns and schedules some work to be done – when the work is done, it will run the next step of the state machine. For example this code:

async Task Demo() { 
  var v1 = foo();
  var v2 = await bar();
  more(v1, v2);
}

Would be translated to something like:

class _Demo {
  int _v1, _v2;
  int _state = 0; 
  Task<int> _await1;
  public void Step() {
    switch(this._state) {
    case 0: 
      this._v1 = foo();
      this._await1 = bar();
      // When the async operation completes, it will call this method
      this._state = 1;
      op.SetContinuation(Step);
    case 1:
      this._v2 = this._await1.Result; // Get the result of the operation
      more(this._v1, this._v2);
  }
}

The important part is that it just uses the SetContinuation method to specify that when the operation completes, it should call the Step method again (and the method knows that it should run the second bit of the original code using the _state field). You can easily imagine that the SetContinuation would be something like btn.Click += Step, which would run completely on a single thread.

The asynchronous programming model in C# is very close to F# asynchronous workflows (in fact, it is essentially the same thing, aside from some technical details), and writing reactive single-threaded GUI applications using async is quite an interesting area – at least I think so – see for example this article (maybe I should write a C# version now :-)).

The translation is similar to iterators (and yield return) and in fact, it was possible to use iterators to implement asynchronous programming in C# earlier. I wrote an article about that a while ago – and I think it can still give you some insight on how the translation works.

More Related Contents:

  1. How and when to use ‘async’ and ‘await’
  2. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  3. HttpClient.GetAsync(…) never returns when using await/async
  4. Should I avoid ‘async void’ event handlers?
  5. Running multiple async tasks and waiting for them all to complete
  6. How do yield and await implement flow of control in .NET?
  7. Fire and forget async method in asp.net mvc
  8. Task sequencing and re-entracy
  9. Enforce an async method to be called once
  10. Why use Async/await all the way down
  11. Async and await – difference between console, Windows Forms and ASP.NET
  12. Different forms of the WCF service contract interface
  13. Why use async and return await, when you can return Task directly?
  14. Executing tasks in parallel
  15. Should I worry about “This async method lacks ‘await’ operators and will run synchronously” warning
  16. Proper way to start and fire-and-forget asynchronous calls?
  17. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  18. A pattern for self-cancelling and restarting task
  19. Async always WaitingForActivation
  20. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  21. A pattern to pause/resume an async task?
  22. Async thread body loop, It just works, but how?
  23. Converting async/await to Task.ContinueWith
  24. Horrible performance using SqlCommand Async methods with large data
  25. How to Async Files.ReadAllLines and await for results?
  26. Async and Await with For Loop [duplicate]
  27. Await and SynchronizationContext in a managed component hosted by an unmanaged app
  28. When is the best place to use Task.Result instead of awaiting Task
  29. Timeout pattern on task-based asynchronous method in C#
  30. What do ref, val and out mean on method parameters?

Leave a Comment