async var for easy and safe parallelism

[YairHalberstadt]

Problem

async/await makes it easy to avoid blocking a thread whilst waiting for some task to complete, and it looks like it should make parallelism easy too. You just kick of all the tasks you can, and then await them at some point in the future, once you've done everything else you can. For example:

public async Task PrepareLunch()
{
    var dessertArrivalTask = OrderDessert();
    var preheatOvenTask = PreHeatOven();
    var vegetables = PrepVegetables();
    var potatoes = PeelPotatoes();
    await preheatOvenTask;
    var cookInOvenTask = CookInOven(potatoes);
    LayTable();
    await cookInOvenTask;
    await dessertArrivalTask;
}

Unfortunately it's not so simple as this. What happens if PrepVegetables throw for example? Then you will never await the dessertArrivalTask or the preheatOvenTask. This can theoretically lead to an UnobservedTaskException which is generally considered a bad thing - so bad in fact that in the past it used to crash the application.

So next stage is this:

public async Task PrepareLunch()
{
    var dessertArrivalTask = OrderDessert();
    try
    {
        Vegetables vegetables;
        Potatoes potatoes;
        var preheatOvenTask = PreHeatOven();
        try
        {
            vegetables = PrepVegetables();
            potatoes = PeelPotatoes();
        }
        catch
        {
            preheatOvenTask.ContinueWith(completedTask => _ = completedTask.Exception, OnlyOnFaulted);
            throw;
        }
        await preheatOvenTask;
        var cookInOvenTask = CookInOven(potatoes);
        try
        {
            LayTable();
        }
        catch
        {
            cookInOvenTask.ContinueWith(completedTask => _ = completedTask.Exception, OnlyOnFaulted);
            throw;
        }
    }
    catch
    {
        dessertArrivalTask.ContinueWith(completedTask => _ = completedTask.Exception, OnlyOnFaulted);
        throw;
    }
    await Task.WhenAll(cookInOvenTask, dessertArrivalTask);
}

This is already bad enough, but it can get worse. What happens if our original sample had an existing try block which stops us putting the try blocks we need to add where they should be, and we were using ValueTasks (this is the exact scenario in my IOC source generator), like so:

public async Task PrepareLunch()
{
    var dessertArrivalTask = OrderDessert();
    var preheatOvenTask = PreHeatOven();
    var vegetables = PrepVegetables();
    try
    {
        var potatoes = PeelPotatoes();
        await preheatOvenTask;
        var cookInOvenTask = CookInOven(potatoes);
        LayTable();
        await cookInOvenTask;
        await dessertArrivalTask;
    }
    finally
    {
        vegetables.DisposeOfLeftovers();
    }
}

Remember we can't use ValueTasks after they've been awaited so now we need to track whether we've awaited them:

public async Task PrepareLunch()
{
    ValueTask dessertArrivalTask = default;
    ValueTask preheatOvenTask = default;
    ValueTask cookInOvenTask = defaul;
    bool handleFaultedDessertArrivalTask = false;
    bool handleFaultedPreheatOvenTask = false;
    bool handleFaultedCookInOvenTask = false;
    try
    { 
        dessertArrivalTask = OrderDessert();
        handleFaultedDessertArrivalTask = true;
        preheatOvenTask = PreHeatOven();
        handleFaultedPreheatOvenTask = true;
        var vegetables = PrepVegetables();
        try
        {
            var potatoes = PeelPotatoes();
            handleFaultedPreheatOvenTask = false;
            await preheatOvenTask;
            cookInOvenTask = CookInOven(potatoes);
            handleFaultedCookInOvenTask = true;
            LayTable();=
            handleFaultedCookInOvenTask = false;
            await cookInOvenTask;
            handleFaultedDessertArrivalTask  = false;
            await dessertArrivalTask;
        }
        finally
        {
            vegetables.DisposeOfLeftovers();
        }
    }
    catch
    {
         if (handleFaultedDessertArrivalTask)
               dessertArrivalTask.AsTask().ContinueWith(completedTask => _ = completedTask.Exception, OnlyOnFaulted);
         if (handleFaultedPreheatOvenTask)
               preheatOvenTask.AsTask().ContinueWith(completedTask => _ = completedTask.Exception, OnlyOnFaulted);
         if (handleFaultedCookInOvenTask)
               cookInOvenTask.AsTask().ContinueWith(completedTask => _ = completedTask.Exception, OnlyOnFaulted);
    }
}

This is not really practical to do (outside source generators), so either people don't bother, and let the UnobservedTaskException trigger, or just don't bother with parallelism and make the whole thing linear.

Suggested Solution: async var

This is inspired by swift's proposed model for concurrency: https://forums.swift.org/t/concurrency-structured-concurrency/41622

A var can be marked as async var like so:

public async Task PrepareLunch()
{
    async var dessertArrivalTask = OrderDessert();
    async var preheatOvenTask = PreHeatOven();
    var vegetables = PrepVegetables();
    var potatoes = PeelPotatoes();
    await preheatOvenTask;
    async var cookInOvenTask = CookInOven(potatoes);
    LayTable();
    await cookInOvenTask;
    await dessertArrivalTask;
}

An async var must have a suitable GetAwaiter method as usual, but the Awaiter must have a method or extension method void CancelOrIgnore(). An async var can only be awaited. It can not be used in any other fashion.

The compiler will generate code such that on any code path where a variable assigned to an async var is not awaited, .GetAwaiter().CancelOrIgnore() will be called instead.

[svick]

I don't understand, why are you working so hard to avoid UnobservedTaskException? Even if it's "generally considered a bad thing" (is it? why?), does automatically calling CancelOrIgnore() actually help? (Especially since it probably can't cancel the underlying computation.)