Assuming I read the question correctly, you are worried about the following sequence of events:
- The button is clicked, task
T0
is scheduled on the thread pool, continuationC0
is scheduled as a continuation ofT0
, to be run on the synchronization context's task scheduler - The button is clicked again. Let's say the message pump is busy doing something else, so now the message queue consists of one item, the click handler.
T0
completes, this causesC0
to be posted to the message queue. The queue now contains two items, the click handler and the execution ofC0
.- The click handler message is pumped, and the handler signals the token driving the cancellation of
T0
andC0
. Then it schedulesT1
on the thread pool andC1
as a continuation in the same manner as step1
. - The 'execute
C0
' message is still in the queue, so it gets processed now. Does it execute the continuation you intended to cancel?
The answer is no. TryExecuteTask will not execute a task which has been signaled for cancellation. It's implied by that documentation, but spelled out explicitly on the TaskStatus page, which specifies
Canceled -- The task acknowledged cancellation by throwing an OperationCanceledException with its own CancellationToken while the token was in signaled state, or the task's CancellationToken was already signaled before the task started executing.
So at the end of the day T0
will be in the RanToCompletion
state and C0
will be in the Canceled
state.
This is all, of course, assuming that the current SynchronizationContext
does not allow tasks to be run concurrently (as you are aware, the Windows Forms one does not -- I'm just noting that this is not a requirement of synchronization contexts)
Also, it's worth noting that the exact answer to your final question about whether the cancellation token is checked in the context of when cancellation is requested or when the task is executed, the answer is really both. In addition to the final check in TryExecuteTask
, as soon as cancellation is requested the framework will call TryDequeue
, an optional operation that task schedulers can support. The synchronization context scheduler does not support it. But if it somehow did, the difference might be that the 'execute C0
' message would be ripped out of the thread's message queue entirely and it wouldn't even try to execute the task.