Getting a meaningful stack trace when using async code

Question

I've created a small bit of code for running multiple async operations in parallel (the Parallel class itself isn't good for async operations).

It looks like this:

public static async Task ForEachAsync<T>(this IEnumerable<T> source, int dop, Func<T, Task> body)
{
    var chunks = source.Chunk(dop);
    foreach (var chunk in chunks)
        await Task.WhenAll(chunk.Select(async s => await body(s).ContinueWith(t => ThrowError(t))));
}

private static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunksize)
{
    while (source.Any())
    {
        yield return source.Take(chunksize);
        source = source.Skip(chunksize);
    }
}

private static void ThrowError(Task t)
{
    if (t.IsFaulted)
    {
        if (t.Exception.InnerExceptions != null && t.Exception.InnerExceptions.Count == 1)
            throw t.Exception.InnerExceptions[0];
        else
            throw t.Exception;
    }
}

As far as running the tasks in parallel goes, the above code works really well. I do, however, have some issues when exceptions are thrown.

The exception-capturing code works well as far as returning the exception message goes, but the stack trace leaves a lot to be desired - as it points to the ThrowError method, rather than the method that originally generated the exception. I can sort of work my way and figure out what went wrong with a debugger attached, but if I ever release this application I won't have that option available - at best, I'll have the exception with the stack trace logged.

So - is there any way to get a more meaningful stack trace when running async tasks?

PS. This is for a WindowsRT application but I think the problem isn't limited to WindowsRT as such...

Answer 1

So - is there any way to get a more meaningful stack trace when running async tasks?

Yes, you can use ExceptionDispatchInfo.Capture that was introduced in .NET 4.5 for async-await speficially:

private static void ThrowError(Task t)
{
    if (t.IsFaulted)
    {
        Exception exception = 
            t.Exception.InnerExceptions != null && t.Exception.InnerExceptions.Count == 1 
                ? t.Exception.InnerExceptions[0] 
                : t.Exception;

        ExceptionDispatchInfo.Capture(exception).Throw();
    }
}

"You can use the ExceptionDispatchInfo object that is returned by this method at another time and possibly on another thread to rethrow the specified exception, as if the exception had flowed from this point where it was captured to the point where it is rethrown. If the exception is active when it is captured, the current stack trace information and Watson information that is contained in the exception is stored. If it is inactive, that is, if it has not been thrown, it will not have any stack trace information or Watson information."

However, keep in mind that exceptions from async code are generally less meaningful than you would like as all exceptions are thrown from inside the MoveNext method on the state machine generated by the compiler.

Answer 2

i3arnon's answer is completely correct, however there's still a few alternatives. The problem you are facing is because throw is the part that captures the stack trace - by throwing the same exception again, you've thrown away the whole stack trace.

The simplest way to avoid that is to let the Task do its job:

t.GetAwaiter().GetResult();

That's it - the exception is rethrown with the correct stack trace and everything. You don't even have to check if the task is faulted - if it is, it will throw, if it isn't, it will not.

Internally, this method uses the ExceptionDispatchInfo.Capture(exception).Throw(); i3arnon has shown, so they are almost equivallent (your code assumes that the task has already completed, faulted or not - if it's not completed yet, IsFaulted will return false).

Answer 3

the above code works really well

I'm not sure why you would want exceptions thrown directly on the thread pool (ContinueWith). This would crash your process without giving any of the code a chance to clean up.

To me, a much more natural approach would be to let the exception bubble up. In addition to allowing natural cleanup, this approach removes all the awkward, weird code:

public static async Task ForEachAsync<T>(this IEnumerable<T> source, int dop, Func<T, Task> body)
{
  var chunks = source.Chunk(dop);
  foreach (var chunk in chunks)
    await Task.WhenAll(chunk.Select(s => body(s)));
}

private static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int chunksize)
{
  while (source.Any())
  {
    yield return source.Take(chunksize);
    source = source.Skip(chunksize);
  }
}

// Note: No "ThrowError" at all.