Whats the benefit of passing a CancellationToken as a parameter to Task.Run?

Question

Obviously I realize it enables me to cancel the task, but this code achieves the same effect without having to pass the token into Task.Run

What is the practical difference? Thanks.

Dim cts As New CancellationTokenSource
Dim ct As CancellationToken = cts.Token
Task.Run(Sub()
             For i = 1 To 1000
                 Debug.WriteLine(i)
                 ct.ThrowIfCancellationRequested()
                 Threading.Thread.Sleep(10)
             Next
         End Sub)

cts.CancelAfter(500)

VS

Dim cts As New CancellationTokenSource
Dim ct As CancellationToken = cts.Token
Task.Run(Sub()
             For i = 1 To 1000
                 Debug.WriteLine(i)
                 ct.ThrowIfCancellationRequested()
                 Threading.Thread.Sleep(10)
             Next
         End Sub, ct)

cts.CancelAfter(500)

Answer 1

The API docs for Task.Run(Action, CancellationToken) has this remark:

If cancellation is requested before the task begins execution, the task does not execute. Instead it is set to the Canceled state and throws a TaskCanceledException exception.

So in your scenario, there isn't any practical difference because you wait 500 milliseconds before issuing the cancellation. In that time the task is scheduled, begins execution, and runs through the loop a number of times before the cancellation is issued, manifesting as an exception thrown from ct.ThrowIfCancellationRequested().

The difference between Task.Run(Action) and Task.Run(Action, CancellationToken) is more apparent with this modified version of your example:

Try
    Dim cts As New CancellationTokenSource
    Dim ct As CancellationToken = cts.Token

    cts.Cancel()

    Dim task As Task = Task.Run(
        Sub()
            Console.WriteLine("Started running your code!")
            ct.ThrowIfCancellationRequested()
            Console.WriteLine("Finished running your code!")
        End Sub, ct)

    task.Wait()

Catch ex As AggregateException
    Console.Error.WriteLine("Caught exception: " & ex.InnerException.Message)
End Try

Console.WriteLine("Done, press Enter to quit.")
Console.ReadLine()

In this scenario, Task.Run schedules the task to run, but also associates the cancellation token with that task. When we call task.Wait(), before the thread pool executes the task, it checks the cancellation token and notices that a cancellation has been issued on that token, so it decides to cancel before executing the task. So the output is:

Caught exception: A task was canceled.
Done, press Enter to quit.

If you instead replace: End Sub, ct) with End Sub), then the thread pool isn't aware of the cancellation token, so even though you've issued a cancellation, it proceeds with executing the task, before your task code itself checks for cancellation. So the output is:

Started running your code!
Caught exception: The operation was canceled.
Done, press Enter to quit.

(You can see that the exception message is slightly different in these two cases as well.)

In summary, providing the cancellation token to the Task.Run method allows the thread pool itself to know if the task is cancelled before the thread pool gets a chance to execute the task. This allows the thread pool to save time and resources by not even bothering to start running the task.