A pattern for self-cancelling and restarting task

by

I think the general concept is pretty good, though I recommend you not use ContinueWith.

I’d just write it using regular await, and a lot of the “am I already running” logic is not necessary:

Task pendingTask = null; // pending session
CancellationTokenSource cts = null; // CTS for pending session

// SpellcheckAsync is called by the client app on the UI thread
public async Task<bool> SpellcheckAsync(CancellationToken token)
{
    // SpellcheckAsync can be re-entered
    var previousCts = this.cts;
    var newCts = CancellationTokenSource.CreateLinkedTokenSource(token);
    this.cts = newCts;

    if (previousCts != null)
    {
        // cancel the previous session and wait for its termination
        previousCts.Cancel();
        try { await this.pendingTask; } catch { }
    }

    newCts.Token.ThrowIfCancellationRequested();
    this.pendingTask = SpellcheckAsyncHelper(newCts.Token);
    return await this.pendingTask;
}

// the actual task logic
async Task<bool> SpellcheckAsyncHelper(CancellationToken token)
{
    // do the work (pretty much IO-bound)
    using (...)
    {
        bool doMore = true;
        while (doMore)
        {
            token.ThrowIfCancellationRequested();
            await Task.Delay(500); // placeholder to call the provider
        }
        return doMore;
    }
}

More Related Contents:

  1. Running multiple async tasks and waiting for them all to complete
  2. Task sequencing and re-entracy
  3. Enforce an async method to be called once
  4. Executing tasks in parallel
  5. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  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 and when to use ‘async’ and ‘await’
  9. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  10. Should I avoid ‘async void’ event handlers?
  11. Awaiting multiple Tasks with different results
  12. Using async/await for multiple tasks
  13. How do yield and await implement flow of control in .NET?
  14. Why should I prefer single ‘await Task.WhenAll’ over multiple awaits?
  15. Best way in .NET to manage queue of tasks on a separate (single) thread
  16. Synchronously waiting for an async operation, and why does Wait() freeze the program here
  17. What is the use for Task.FromResult in C#
  18. Why use Async/await all the way down
  19. Revisiting Task.ConfigureAwait(continueOnCapturedContext: false)
  20. Async and await – difference between console, Windows Forms and ASP.NET
  21. Different forms of the WCF service contract interface
  22. If my interface must return Task what is the best way to have a no-operation implementation?
  23. Should I worry about “This async method lacks ‘await’ operators and will run synchronously” warning
  24. Task.Factory.StartNew with async lambda and Task.WaitAll
  25. Async thread body loop, It just works, but how?
  26. How to throttle multiple asynchronous tasks?
  27. Synchronous implementation of interface that returns Task
  28. How do I get a return value from Task.WaitAll() in a console app?
  29. Timeout pattern on task-based asynchronous method in C#
  30. Wrapping ManualResetEvent as awaitable task

Leave a Comment