How to handle task cancellation in the TPL

Question

Good day! I am writing a helper library for WinForms UI. Started using TPL async/await mechanism and got a problem with this kind of code example :

    private SynchronizationContext _context;

    public void UpdateUI(Action action)
    {
        _context.Post(delegate { action(); }, null);
    }


    private async void button2_Click(object sender, EventArgs e)
    {

        var taskAwait = 4000;
        var progressRefresh = 200;
        var cancellationSource = new System.Threading.CancellationTokenSource();

        await Task.Run(() => { UpdateUI(() => { button2.Text = "Processing..."; }); });

        Action usefulWork = () =>
        {
            try
            {
                Thread.Sleep(taskAwait);
                cancellationSource.Cancel();
            }
            catch { }
        };
        Action progressUpdate = () =>
        {
            int i = 0;
            while (i < 10)
            {
                UpdateUI(() => { button2.Text = "Processing " + i.ToString(); });
                Thread.Sleep(progressRefresh);
                i++;
            }
            cancellationSource.Cancel();
        };

        var usefulWorkTask = new Task(usefulWork, cancellationSource.Token);
        var progressUpdateTask = new Task(progressUpdate, cancellationSource.Token);

        try
        {
            cancellationSource.Token.ThrowIfCancellationRequested();
            Task tWork = Task.Factory.StartNew(usefulWork, cancellationSource.Token);
            Task tProgress = Task.Factory.StartNew(progressUpdate, cancellationSource.Token);
            await Task.Run(() =>
            {
                try
                {
                    var res = Task.WaitAny(new[] { tWork, tProgress }, cancellationSource.Token);                        
                }
                catch { }
            }).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
        }
        await Task.Run(() => { UpdateUI(() => { button2.Text = "button2"; }); });
    }

Basically, the idea is to run two parallel tasks - one is for, say, progress bar or whatever update and a sort of timeout controller, the other is the long running task itself. Whichever task finishes first cancels the other one. So, there should not be a problem to cancel the "progress" task as it has a loop in which I can check if task is marked cancelled. The problem is with the long running one. It could be Thread.Sleep() or SqlConnection.Open(). When I run CancellationSource.Cancel(), the long running task keeps working and does not cancel. After a timeout I am not interested in long running task or whatever it may result in.
As the cluttered code example may suggest, I have tried a bunch of variants and none given me a desired effect. Something like Task.WaitAny() freezes UI... Is there a way to make that cancellation work or may be even a different approach to code these things?

UPD:

public static class Taskhelpers
{
    public static async Task<T> WithCancellation<T>(this Task<T> task, CancellationToken cancellationToken)
    {
        var tcs = new TaskCompletionSource<bool>();
        using (cancellationToken.Register(s => ((TaskCompletionSource<bool>)s).TrySetResult(true), tcs))
        {
            if (task != await Task.WhenAny(task, tcs.Task))
                throw new OperationCanceledException(cancellationToken);
        }
        return await task;
    }
    public static async Task WithCancellation(this Task task, CancellationToken cancellationToken)
    {
        var tcs = new TaskCompletionSource<bool>();
        using (cancellationToken.Register(s => ((TaskCompletionSource<bool>)s).TrySetResult(true), tcs))
        {
            if (task != await Task.WhenAny(task, tcs.Task))
                throw new OperationCanceledException(cancellationToken);
        }
        await task;
    }
}

.....

        var taskAwait = 4000;
        var progressRefresh = 200;
        var cancellationSource = new System.Threading.CancellationTokenSource();
        var cancellationToken = cancellationSource.Token;

        var usefulWorkTask = Task.Run(async () =>
        {
            try
            {
                System.Diagnostics.Trace.WriteLine("WORK : started");

                await Task.Delay(taskAwait).WithCancellation(cancellationToken);

                System.Diagnostics.Trace.WriteLine("WORK : finished");
            }
            catch (OperationCanceledException) { }  // just drop out if got cancelled
            catch (Exception ex)
            {
                System.Diagnostics.Trace.WriteLine("WORK : unexpected error : " + ex.Message);
            }
        }, cancellationToken);

        var progressUpdatetask = Task.Run(async () =>
        {
            for (var i = 0; i < 25; i++)
            {
                if (!cancellationToken.IsCancellationRequested)
                {
                    System.Diagnostics.Trace.WriteLine("==== : " + i.ToString());
                    await Task.Delay(progressRefresh);
                }
            }
        },cancellationToken);

        await Task.WhenAny(usefulWorkTask, progressUpdatetask);

        cancellationSource.Cancel();

By modifying for (var i = 0; i < 25; i++) limit of i I imitate whether long running task finishes before the progress task or otherwise. Works as desired. The WithCancellation helper method does the job, although two sort of 'nested' Task.WhenAny look suspicious for now.

Answer 1

When you write something like await Task.Run(() => { UpdateUI(() => { button2.Text = "Processing..."; }); }); on your button2_Click, you are, from the UI thread, scheduling an action to a thread poll thread that posts an action to the UI thread. If you called the action directly, it would be quickier because it wouldn't have two context switchings.

ConfigureAwait(false) causes the synchronization context to not being captured. I should not be used inside UI methods because, you most certainely, want to do some UI work on the continuation.

You shouldn't use Task.Factory.StartNew instead of Task.Run unless you absolutely have a reason to. See this and this.

For progress updates, consider using the Progress<T> class, because it captures the synchronization context.

Maybe you should try something like this:

private async void button2_Click(object sender, EventArgs e)
{
    var taskAwait = 4000;
    var cancellationSource = new CancellationTokenSource();
    var cancellationToken = cancellationSource.Token;
    
    button2.Text = "Processing...";
    
    var usefullWorkTask = Task.Run(async () =>
        {
            try
            {
                await Task.Dealy(taskAwait);
            }
            catch { }
        },
        cancellationToken);
    
    var progress = new Progress<imt>(i => {
        button2.Text = "Processing " + i.ToString();
    });

    var progressUpdateTask = Task.Run(async () =>
        {
            for(var i = 0; i < 10; i++)
            {
                progress.Report(i);
            }
        },
        cancellationToken);
        
    await Task.WhenAny(usefullWorkTask, progressUpdateTask);
    
    cancellationSource.Cancel();
}

Answer 2

I agree with all the points in Paulo's answer - namely, use modern solutions (Task.Run instead of Task.Factory.StartNew, Progress<T> for progress updates instead of manually posting to the SynchronizationContext, Task.WhenAny instead of Task.WaitAny for asynchronous code).

But to answer the actual question:

When I run CancellationSource.Cancel(), the long running task keeps working and does not cancel. After a timeout I am not interested in long running task or whatever it may result in.

There are two parts to this:

• How do I write code that responds to a cancellation request?
• How do I write code that ignores any responses after the cancellation?

Note that the first part deals with cancelling the operation, and the second part is actually dealing with cancelling the waiting for the operation to complete.

First things first: support cancellation in the operation itself. For CPU-bound code (i.e., running a loop), periodically call token.ThrowIfCancellationRequested(). For I/O-bound code, the best option is to pass the token down to the next API layer - most (but not all) I/O APIs can (should) take cancellation tokens. If this isn't an option, then you can either choose to ignore the cancellation, or you can register a cancellation callback with token.Register. Sometimes there's a separate cancellation method you can call from your Register callback, and sometimes you can make it work by disposing the object from the callback (this approach often works because of a long-standing Win32 API tradition of cancelling all I/O for a handle when that handle is closed). I'm not sure if this will work for SqlConnection.Open, though.

Next, cancelling the wait. This one is relatively simple if you just want to cancel the wait due to a timeout:

await Task.WhenAny(tWork, tProgress, Task.Delay(5000));

Answer 3

I think you need to check IsCancellationRequested in the progressUpdate Action.

As to how to do what you want, this blog discusses an Extension method WithCancellation that will make it so that you stop waiting for your long running task.