Question

I have this code:

    public async Task AsyncMethod()
    {
        await Task.Factory.StartNew(() =>
        {
            throw new Exception();
        });
    }

    public ActionResult Index()
    {
        var t1 = Task.Factory.StartNew(() => { throw new Exception(); });
        var t2 = Task.Factory.StartNew(() => { throw new Exception();});
        var t3 = Task.Factory.StartNew(async () => { await AsyncMethod(); });

        try 
        {
            Task.WaitAll(t1, t2, t3);
        }
        catch (AggregateException ex)
        {
            var count1 = ex.InnerExceptions.Count;
            var count2 = ex.Flatten().InnerExceptions.Count;

            throw;
        }

        return View();
    }

I would like to understand why the count1 and count2 variables are 2 and not 3 and how can I get the third exception inside AsyncMethod?

Answer 1

I would like to understand why the count1 and count2 variables are 2 and not 3 and how can I get the third exception inside AsyncMethod?

Task.Factory.StartNew returns a basic Task. If you pass it an async delegate, then the returned Task only represents the beginning of the async method (up until the point it yields to its caller).

You should be using Task.Run with async code. Task.Run will create a Task wrapper for an async delegate, so the Task returned from Task.Run represents the entire async method.

Stephen Toub has an excellent blog post detailing the differences between Task.Run and Task.Factory.StartNew.

Also, as usr mentioned, you have problems with deadlocks whenever you block on Task rather than await it in a GUI or ASP.NET context. I have a blog post that goes into detail about this deadlock problem. You should use await Task.WhenAll instead of Task.WaitAll.

So, here’s your code with both changes applied:

public async Task AsyncMethod()
{
    await Task.Run(() =>
    {
        throw new Exception();
    });
}

public async Task<ActionResult> Index()
{
    var t1 = Task.Run(() => { throw new Exception(); });
    var t2 = Task.Run(() => { throw new Exception();});
    var t3 = Task.Run(async () => { await AsyncMethod(); });

    try 
    {
        await Task.WhenAll(t1, t2, t3);
    }
    catch (Exception)
    {
        var ex1 = t1.Exception.InnerException;
        var ex2 = t2.Exception.InnerException;
        var ex3 = t3.Exception.InnerException;

        throw;
    }

    return View();
}