CancellationTokenSource in using block inconsistently triggers AsyncFixer04

[evieeddins]

I'm using a CancellationTokenSource for two asynchronous actions, then awaiting them using Task.WhenAny

But this is triggering AsyncFixer (Code AsyncFixer04) in a way that I don't understand.
If I set the scope of the CancellationTokenSource with a using statement in brackets, like so

using System.Threading;
using System.Threading.Tasks;

namespace AsyncFixerIssue
{
    internal class Program
    {
        static Task Main(string[] args)
        {
            using (var cts = new CancellationTokenSource())
            {
                var a = Task.Delay(1, cts.Token);
                var b = Task.Delay(1, cts.Token);

                return Task.WhenAny(a, b);
            }
        }
    }
}

it triggers a warning from AsyncFixer04.

But if I format it like this, there's no problem

static Task Main(string[] args)
{
    using var cts = new CancellationTokenSource();
    var a = Task.Delay(1, cts.Token);
    var b = Task.Delay(1, cts.Token);

    return Task.WhenAny(a, b);
}

Also, I can just set cts.Token to a variable and make the analyzer happy

static Task Main(string[] args)
{
    using (var cts = new CancellationTokenSource())
    {
        var cancellationToken = cts.Token;
        var a = Task.Delay(1, cancellationToken);
        var b = Task.Delay(1, cancellationToken);

        return Task.WhenAny(a, b);
    }
}

It seems like either all of these should trigger the analyzer, or none of them should.
Is this a bug?
If not, what's your recommended fix for passing along a CancellationTokenSource?

[semihokur]

Thanks for the detailed report!

This is expected behavior, though I understand it can seem inconsistent. Let me explain what's happening:

Why the warning triggers for pattern 1

using (var cts = new CancellationTokenSource())
{
    var a = Task.Delay(1, cts.Token);  // 'cts' is used here
    return Task.WhenAny(a, b);         // Task returned without awaiting
}

The analyzer detects that cts (the disposable) is used in an async call, and the task is ultimately returned from the using block without being awaited. This is a legitimate warning because cts will be disposed when the method returns, but the tasks using cts.Token may still be running.

Why pattern 2 (using declaration) doesn't trigger

I've confirmed this is actually a bug in the analyzer. The using var pattern should trigger the same warning but currently doesn't for this scenario. I'll look into fixing this.

Why pattern 3 doesn't trigger

var cancellationToken = cts.Token;
var a = Task.Delay(1, cancellationToken);  // 'cancellationToken' is used, not 'cts'

The analyzer tracks usage of the disposable identifier (cts) in async calls. When you assign cts.Token to a local variable cancellationToken, the subsequent async calls use cancellationToken, not cts directly. The analyzer doesn't perform data-flow analysis to track that cancellationToken originated from cts.

Is this a real problem in the code?

Yes! All three patterns have the same underlying issue: the CancellationTokenSource will be disposed before the returned task completes. The correct fix is to either:

1. Await the task before exiting the using block:

   using (var cts = new CancellationTokenSource())
   {
       var a = Task.Delay(1, cts.Token);
       var b = Task.Delay(1, cts.Token);
       return await Task.WhenAny(a, b);
   }

2. Don't use a using block and handle disposal when the task completes

Summary

• Pattern 1: Warning is correct
• Pattern 2: Should warn but doesn't - this is a bug
• Pattern 3: Doesn't warn due to lack of data-flow analysis - could be improved in the future but is lower priority since this pattern is less common