is it necessary to cancel cancellationtoken before disposal

Question

I'm using CancellationTokenSource for timeout purposes most of the time. To avoid forgetting dispose, when I'm done with the CancellationTokenSource, I'm using a using statement. But before the end of the using statement, I'm always doing a CancellationTokenSource.Cancel().

Is it necessary to cancel CancellationTokenSource before disposal if the cancellation hasn't been used?

Here is an example of code where I'm doing this.

using (CancellationTokenSource TokenSource = new CancellationTokenSource(nTimeout * 1000))
{
  for (int i = 0; i < nLoop; i++)
  {
    if (TokenSource.Token.IsCancellationRequested)
    {
      bSuccess = false;
      break;
    }

    await Task.Delay(cDelay);
    // do some work
  }

  TokenSource.Cancel();
}

Answer 1

After a CancellationTokenSource has been disposed tokens based on this source may throw ObjectDisposedException so you should not use CancellationTokenSource.Token after the source has been disposed. Fortunately, I don't see this happening in your code.

When you cancel a CancellationTokenSource it changes state and notifies callbacks that have been registered for the token. However, when your code is about to dispose the CancellationTokenSource you are already done using the token and there is no need to cancel it.

So in your case it is not necessary to cancel the CancellationTokenSource before disposing it. However, your use case is somewhat special. When you have a background task you should wait for the task to complete before disposing the source (as stated in my initial paragraph):

using (var cts = new CancellationTokenSource()) {
    var task = Task.Run(() => DoSomething(cts.Token));
    // Cancel cts or let it cancel itself based on a timeout.
    // Then wait for the task to end.
    await task;
}

Answer 2

For the question "Is it necessary to cancel CancellationTokenSource before disposal?" the answer is no, it's not necessary. But canceling it or not determines the final state of the the orphaned token.

As a general rule, an orphaned token should not be used after disposing it's source. But if you're curious what happens if you try to use it anyway, it should work to some extent. For example check this test:

[Theory]
[InlineData(false)]
[InlineData(true)]
public void Test48538934(bool canceledBeforeDispose)
{
    var cts = new CancellationTokenSource();
    var ct = cts.Token;

    Assert.False(cts.IsCancellationRequested);
    Assert.False(ct.IsCancellationRequested);

    if (canceledBeforeDispose)
        cts.Cancel();

    Assert.Equal(canceledBeforeDispose, cts.IsCancellationRequested);
    Assert.Equal(canceledBeforeDispose, ct.IsCancellationRequested);

    cts.Dispose();

    Assert.Throws<ObjectDisposedException>(() => cts.Token);

    Assert.Equal(canceledBeforeDispose, cts.IsCancellationRequested);
    Assert.Equal(canceledBeforeDispose, ct.IsCancellationRequested);
}

So in case that a token is accidentally lost somewhere in the asynchronous calls pipeline, canceling the source before disposing it might be desirable.

Answer 3

If you want your operations to be notified about cancellation, then yes you should explicitly call Cancel before Dispose. Usually this is a good thing.

MS also make this explicit in their documentation:

Note that calling Dispose does not communicate a request for cancellation to consumers of the associated Token. You can communicate a request for cancellation by calling methods such as Cancel or CancelAfter.