Asynchronous Tasks, Cancellations and Exceptions

I always recommend people read Cancel in the managed thread docs. It's not entirely complete; like most MSDN docs, it tells you what you can do, not what you should be doing. But that's definitely clearer than the dotnet cancellation docs.

The example shows basic usage

Firstly, it is important to note that the cancellation in your code example overrides the problem - it does not cancel the basic operation. I highly recommend that you do not do this.

If you want to undo the operation, you will need to update RunFoo

in order to take CancellationToken

(see below how he should use it):

public Task Run(IFoo foo, CancellationToken token = default(CancellationToken)) {
  var tcs = new TaskCompletionSource<object>();

  // Regular finish handler
  EventHandler<AsyncCompletedEventArgs> callback = (sender, args) =>
  {
    if (args.Cancelled)
    {
      tcs.TrySetCanceled(token);
      CleanupFoo(foo);
    }
    else
      tcs.TrySetResult(null);
  };

  RunFoo(foo, token, callback);
  return tcs.Task;
}

      

        
        
        
      

    

If you cannot cancel foo

, then there is no need to cancel API support at all:

public Task Run(IFoo foo) {
  var tcs = new TaskCompletionSource<object>();

  // Regular finish handler
  EventHandler<EventArgs> callback = (sender, args) => tcs.TrySetResult(null);

  RunFoo(foo, callback);
  return tcs.Task;
}

      

        
        
        
      

    

Callers can then perform a lazy wait on the task, which is a much more appropriate coding technique for this scenario (since it is the wait that is canceled, not the operation represented by the task). Doing "undo wait" can be done using my AsyncEx.Tasks library , or you can write your own equivalent extension method.

The documentation says it either just returns, has a task state switch in RanToCompletion, or throws an OperationCanceledException (which causes the task result to be canceled).

Yes, these documents are misleading. First, please don't just come back; your method will complete the task successfully - showing that the operation was successful - when the operation did not complete successfully. This might work for some code, but of course it's not a good idea.

Generally, the correct way to answer CancellationToken

is as follows:

• Call periodically ThrowIfCancellationRequested
  
  . This option is better suited for processor bound code.
• Register a cancellation callback via Register
  
  . This option is better for I / O related code. Please note that registration must be deleted!

In your particular case, you have an unusual situation. In your case, I would take the third approach:

• In your "work with personnel" check token.IsCancellationRequested
  
  ; if requested, then raise the callback event with AsyncCompletedEventArgs.Cancelled
  
  set to true
  
  .

This is logically equivalent to the first correct path (by calling periodically ThrowIfCancellationRequested

), catching the exception and translating it into an event notification. Simply without exception.

I always get a TaskCanceledException if I expect a task to return. My guess would be that this is normal behavior (I hope it is) and that I expect to enable / disable the call when I want to use cancellation.

The native consumption code for a canceled task is to wrap await

in try / catch and catch OperationCanceledException

. For various reasons (many historical), some APIs will be called OperationCanceledException

and some will be called TaskCanceledException

. Since it TaskCanceledException

comes from OperationCanceledException

, the consumer code might just get a more general exception.

But my guess is that if the user wants to distinguish between a job that ended normally and one that was canceled, [the cancellation exception] is pretty much a side effect of ensuring that, right?

This is the accepted pattern , yes.

The documentation assumes that any exceptions, even those related to cancellation, are wrapped in AGLATEException TPL.

This is only true if your code blocks the task synchronously. Which he should really avoid doing in the first place. Therefore, the documents are certainly misleading.

However, in my tests, I always got the TaskCanceledException directly, without any wrapper.

await

avoids the wrapper AggregateException

.

Update for comments explaining CleanupFoo

is the undo method.

First, I recommend using CancellationToken

directly in your code triggered RunFoo

; this approach will almost certainly be easier.

However, if you want to use CleanupFoo

to undo, you need Register

it. You will need to remove this registration, and the easiest way to do this might be to split it into two different methods:

private Task DoRun(IFoo foo) {
  var tcs = new TaskCompletionSource<object>();

  // Regular finish handler
  EventHandler<EventArgs> callback = (sender, args) => tcs.TrySetResult(null);

  RunFoo(foo, callback);
  return tcs.Task;
}

public async Task Run(IFoo foo, CancellationToken token = default(CancellationToken)) {
  var tcs = new TaskCompletionSource<object>();
  using (token.Register(() =>
      {
        tcs.TrySetCanceled(token);
        CleanupFoo();
      });
  {
    var task = DoRun(foo);
    try
    {
      await task;
      tcs.TrySetResult(null);
    }
    catch (Exception ex)
    {
      tcs.TrySetException(ex);
    }
  }
  await tcs.Task;
}

      

        
        
        
      

    

Correctly coordinating and disseminating results - while preventing resource leaks - is rather inconvenient. If your code could be used CancellationToken

directly, that would be much cleaner.