How to timeout a task AND make sure it ends

This post starts from a simple question: how do I start a task with timeout? You go to StackOverflow, of course, and find this answer: Asynchronously wait for Task<T> to complete with timeout. It's an elegant solution, mainly to also start a Task.Delay and continue when either task completes. However, in order to cancel the initial operation, one needs to pass the cancellation token to the original task and manually handle it, meaning polluting the entire business code with cancellation logic. This might be OK, yet are there alternatives?

But, isn't there the Task.Run(action) method that also accepts a CancellationToken? Yes, there is, and if you thought this runs an action until you cancel it, think again. Here is what Task.Run says it does: "Queues the specified work to run on the thread pool and returns a Task object that represents that work. A cancellation token allows the work to be cancelled." and if you scroll down to Remarks, here is what it actually does: "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". You read that right: the token is only taken into account when the task starts running, not while it is actually executing.

Surely, then, there must be a way to cancel a running Task. How about Task.Dispose()? Dispose throws a funny exception if you try it: "System.InvalidOperationException: 'A task may only be disposed if it is in a completion state (RanToCompletion, Faulted or Canceled).'". In normal speech, it means "Fuck you!". If you think about it, how would you abort a task execution? What if it does nasty things, leaves resources occupied, has to clean up after it? The .NET team took the safe path and refused to give you an out of the box unsafe cancelling mechanism.

So, what is the solution? The recommended one is that you pass the token to all methods that can be cancelled and then check inside if cancellation was requested. Of course this only works if

1. you control what the task does
2. you can split the operation into small chunks that are either executed sequentially or in a loop so you interrupt their flow

. If you have something like an external process that is being executed, or a long running operation, you are almost out of luck. Why almost? Well, CancellationSource or CancellationToken do not have events, but the token exposes a "wait handle" that you can wait for synchronously. And here it gets funky. Check out an example of a method that executes some long running action and can react to token cancelling:

/// <summary>
/// Executes the long running action and cancels it when needed
/// </summary>
/// <param name="token"></param>
private void LongRunningAction(CancellationToken token)
{
    // instantiate a container and keep its reference
    var container = new IdentificationContainer();
    Task.Run(() =>
    {
        // wait until the token gets cancelled on another thread
        token.WaitHandle.WaitOne();
        // this will use the information in the container to kill the action
        // (presumably by interrupting external processes or sending some kill signal)
        KillLongRunningAction();
    });
    // this executes the action and populates the identification container if needed
    RunLongRunningAction();
}

This introduces some other issues, like what happens to the monitoring task if you never cancel the token or dispose of the cancellation source, but that's a bit too deep.

In the code above we get a sort of a solution if we can control the code and we can actually cancel things gracefully inside of it. But what if I can't (or won't)? Can I get something that does what I wanted Task.Run to do: execute something and, when I cancel it, stop it from executing?

And the answer, using what we learned above, is yes, but as explained at the beginning, it may have effects like resource leaks. Here it is:

/// <summary>
/// Run an action and kill it when canceling the token
/// </summary>
/// <param name="action">The action to execute</param>
/// <param name="token">The token</param>
/// <param name="waitForGracefulTermination">If set, the task will be killed with delay so as to allow the action to end gracefully</param>
private static Task RunCancellable(Action action, CancellationToken token, TimeSpan? waitForGracefulTermination=null)
{
    // we need a thread, because Tasks cannot be forcefully stopped
    var thread = new Thread(new ThreadStart(action));
    // we hold the reference to the task so we can check its state
    Task task = null;
    task = Task.Run(() =>
    {
        // task monitoring the token
        Task.Run(() =>
        {
            // wait for the token to be canceled
            token.WaitHandle.WaitOne();
            // if we wanted graceful termination we wait
            // in this case, action needs to know about the token as well and handle the cancellation itself
            if (waitForGracefulTermination != null)
            {
                Thread.Sleep(waitForGracefulTermination.Value);
            }
            // if the task has not ended, we kill the thread
            if (!task.IsCompleted)
            {
                thread.Abort();
            }
        });
        // simply start the thread (and the action)
        thread.Start();
        // and wait for it to end so we return to the current thread
        thread.Join();
        // throw exception if the token was canceled
        // this will not be reached unless the thread completes or is aborted
        token.ThrowIfCancellationRequested();
    }, token);
    return task;
}

As you can see, the solution is to run the action on a thread and then manually kill the thread. This means that any control of where and how the action is executed is wrestled from the default TaskScheduler and given to you. Also, in order to force the stopping of the task, you use Thread.Abort, which may have nasty side effects. Here is what Microsoft says about it:



Bummer! .NET Core doesn't want you to kill threads. However, if you are really determined, there is a way :) Use ThreadEx.Abort(thread);


Bonus code: How do you get the cancellation token if you have the task?

var token = new TaskCanceledException(task).CancellationToken;

It might not help too much, especially if you want to use it inside the task itself, but it might help clean up the code.

Conclusion

Just like async/await, using the provided cancellation token method will only pollute your code with little effect. However, considering you want to use a common interface for the purpose, use RunCancellable instead of Task.Run and handle the token manually whenever you feel resources have been allocated and need to be cleaned up first.