C＃“等待”实际上返回什么？

Question

Below is some code that runs "as is" in LinqPad. It demonstrates my misunderstanding of what await is doing. See further down for results and my issue.

    void Main()
{
    var cts = new CancellationTokenSource();
    StartIt(cts.Token);
    Thread.Sleep(500);
    "Cancelling".Dump();
    cts.Cancel();
}


// Define other methods and classes here
async Task StartIt(CancellationToken token)
{
    "StartIt".Dump();
    var o = new TestClass();

    await o.Step0(token);

}

public class TestClass
{
    public async Task Step0(CancellationToken token)
    {
        var t = Step1(token);
        ("Step0.Task.Id => " + t.Id).Dump();        

        await t;
        ("Step0.IsCancelled? " + t.IsCanceled).Dump();
    }

    public async Task Step1(CancellationToken token)
    {
        var t = Step2(token);
        ("Step1.Task.Id => " + t.Id).Dump();

        try {
            await t;
        }
        catch (OperationCanceledException)
        {
            "Step1.OperationCanceledException".Dump();
        }
        ("Step1.IsCancelled? " + t.IsCanceled).Dump();
    }

    public Task Step2(CancellationToken token)
    {
        return Task.Run(() =>{
                Thread.Sleep(3000);
                token.ThrowIfCancellationRequested();
                "Done".Dump();
            }, token);
    }
}

So the above produces:

StartIt
Step1.Task.Id => 17
Step0.Task.Id => 18
Cancelling
Step1.OperationCanceledException
Step1.IsCancelled? True
Step0.IsCancelled? False

My issues:

I expect Step0's and Step1's task.Id to be the same. (therefore) I expect the cancellation that occurs to propagate up the methods so that I can interrogate t.IsCanceled and take appropriate action.

But I'm getting a different Task being returned to Step0 . What am I missing?

Thanks

Answer 1

I recommend that you read my introduction to async . Also, there's an excellent tutorial built-in to LinqPad (Samples -> Download/import more samples -> Asynchrony in C# 5 Interactive Tutorial).

Task identifiers in async code can be a bit tricky. What happens is that every async Task method creates its own task that represents that method invocation. So, Task.Run creates a Task and returns it to Step2 and Step1 (id 17 in your test). Step1 also creates a Task and returns it to Step0 (id 18 in your test). Step0 also creates a Task and returns it to StartIt , and StartIt also creates a Task and returns it to Main .

So, the Task returned by Task.Run (which is the same Task returned by Step2 ) is cancelled. Step1 catches the cancelled exception, so it returns normally, and the Task returned by Step1 is not cancelled.

If you want to propagate exceptions, don't catch the cancelled exception (or if you do want to catch it to log, then re-throw it via throw; ).