How do I create a custom SynchronizationContext so that all continuations can be processed by my own single-threaded event loop?

by

Implementing a custom SynchronizationContext is not the easiest thing in the world. I have an open-source single-threaded implementation here that you can use as a starting point (or possibly just use in place of your main loop).

By default, AsyncContext.Run takes a single delegate to execute and returns when it is fully complete (since AsyncContext uses a custom SynchronizationContext, it is able to wait for async void methods as well as regular async/sync code).

AsyncContext.Run(async () => await DoSomethingAsync());

If you want more flexibility, you can use the AsyncContext advanced members (these do not show up in IntelliSense but they are there) to keep the context alive until some external signal (like “exit frame”):

using (var context = new AsyncContext())
{
  // Ensure the context doesn't exit until we say so.
  context.SynchronizationContext.OperationStarted();

  // TODO: set up the "exit frame" signal to call `context.SynchronizationContext.OperationCompleted()`
  // (note that from within the context, you can alternatively call `SynchronizationContext.Current.OperationCompleted()`

  // Optional: queue any work you want using `context.Factory`.

  // Run the context; this only returns after all work queued to this context has completed and the "exit frame" signal is triggered.
  context.Execute();
}

AsyncContext‘s Run and Execute replace the current SynchronizationContext while they are running, but they save the original context and set that as current before returning. This allows them to work nicely in a nested fashion (e.g., “frames”).

(I’m assuming by “frame” you mean a kind of WPF-like dispatcher frame).

More Related Contents:

  1. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  2. What is the difference between asynchronous programming and multithreading?
  3. How to protect resources that may be used in a multi-threaded or async environment?
  4. Named Mutex with await
  5. What thread runs the code after the `await` keyword?
  6. Is .GetAwaiter().GetResult(); safe for general use?
  7. Async thread body loop, It just works, but how?
  8. I thought await continued on the same thread as the caller, but it seems not to
  9. Synchronous implementation of interface that returns Task
  10. Async and Await with For Loop [duplicate]
  11. Calling TaskCompletionSource.SetResult in a non blocking manner
  12. Catch an exception thrown by an async void method
  13. Should I avoid ‘async void’ event handlers?
  14. Fire and forget async method in asp.net mvc
  15. Why File.ReadAllLinesAsync() blocks the UI thread?
  16. How can I call an async method in Main?
  17. Cancelling a pending task synchronously on the UI thread
  18. Using async without await
  19. ConfigureAwait pushes the continuation to a pool thread
  20. How does async works in C#?
  21. Async/Await – is it *concurrent*?
  22. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  23. Async ShowDialog
  24. Horrible performance using SqlCommand Async methods with large data
  25. How to throttle multiple asynchronous tasks?
  26. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  27. How do you implement an async action delegate method?
  28. Write to a file from multiple threads asynchronously c#
  29. call async method without await #2
  30. Wrapping ManualResetEvent as awaitable task

Leave a Comment