Task sequencing and re-entracy

by

I almost forgot it’s possible to construct a Task manually, without starting or scheduling it. Then, “Task.Factory.StartNew” vs “new Task(…).Start” put me back on track. I think this is one of those few cases when the Task<TResult> constructor may actually be useful, along with nested tasks (Task<Task<T>>) and Task.Unwrap():

// AsyncOp
class AsyncOp<T>
{
    Task<T> _pending = Task.FromResult(default(T));

    public Task<T> CurrentTask { get { return _pending; } }

    public Task<T> RunAsync(Func<Task<T>> handler, bool useSynchronizationContext = false)
    {
        var pending = _pending;
        Func<Task<T>> wrapper = async () =>
        {
            // await the prev task
            var prevResult = await pending;
            Console.WriteLine("\nprev task result:  " + prevResult);
            // start and await the handler
            return await handler();
        };

        var task = new Task<Task<T>>(wrapper);
        var inner = task.Unwrap();
        _pending = inner;

        task.RunSynchronously(useSynchronizationContext ?
            TaskScheduler.FromCurrentSynchronizationContext() :
            TaskScheduler.Current);

        return inner;
    }
}

The output:

Test #1...

prev task result:  0
this task arg: 1000

prev task result:  1000
this task arg: 900

prev task result:  900
this task arg: 800

Press any key to continue to test #2...


prev task result:  800
this task arg: 100

prev task result:  100
this task arg: 200

It’s now also very easy to make AsyncOp thread-safe by adding a lock to protect _pending, if needed.

Updated, this has been further improved with cancel/restart logic.

More Related Contents:

  1. Running multiple async tasks and waiting for them all to complete
  2. Enforce an async method to be called once
  3. Executing tasks in parallel
  4. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  5. A pattern for self-cancelling and restarting task
  6. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  7. Converting async/await to Task.ContinueWith
  8. How to limit the amount of concurrent async I/O operations?
  9. HttpClient.GetAsync(…) never returns when using await/async
  10. Catch an exception thrown by an async void method
  11. Calling async method synchronously
  12. StaTaskScheduler and STA thread message pumping
  13. TAP global exception handler
  14. Regarding usage of Task.Start() , Task.Run() and Task.Factory.StartNew()
  15. Synchronously waiting for an async operation, and why does Wait() freeze the program here
  16. How to use non-thread-safe async/await APIs and patterns with ASP.NET Web API?
  17. Waiting for async/await inside a task
  18. Revisiting Task.ConfigureAwait(continueOnCapturedContext: false)
  19. Async and await – difference between console, Windows Forms and ASP.NET
  20. multiple awaits vs Task.WaitAll – equivalent?
  21. Why use async and return await, when you can return Task directly?
  22. Difference between returning and awaiting a Task in an async method [duplicate]
  23. Proper way to start and fire-and-forget asynchronous calls?
  24. Async always WaitingForActivation
  25. How to correctly write Parallel.For with async methods
  26. A pattern to pause/resume an async task?
  27. How to Async Files.ReadAllLines and await for results?
  28. The lack of non-capturing Task.Yield forces me to use Task.Run, why follow that?
  29. Timeout pattern on task-based asynchronous method in C#
  30. Wrapping ManualResetEvent as awaitable task

Leave a Comment