Treatment of exceptions of different types

Question

try {
    await DoFooAsync();
} catch (Exception e) {
    if(e is TaskCancelledException || e is UnauthorizedAccessException) {
        // ...
    }
    throw;
}

The block catch from the above section checks the type of exception captured with a conditional block. As I will do the same treatment for TaskCancelledException and UnauthorizedAcessException, to avoid code rewriting with two blocks catch with the same calls, I did as above.

However, there is another way to do it using the statement when. Behold:

try {
    await DoFooAsync();
} catch (Exception e) when (e is TaskCancelledException || e is UnauthorizedAccessException) {
    // ...
}

There is no practical difference. As far as I could see the two result the same.

What is the difference in the execution of the two? Which is preferable and why?

Answer 1

There is, yes, the first changes the stack trace, the second no.

The first one intercepts the exception thrown and throws another exception there. The content may be the same, but the location is different. The second holds the stack trace intact indicating the actual origin of the error, so this is preferable. As you are bubbling the exception to other places you can see that shows the origin in a different place, the first will consider that the exception occurred right there, but it occurred before.

It is not a resource that will be very necessary, at least if the person your exception correctly, ie does not keep capturing anything, but it is useful when needed. It was put in the language because the compiler of the C# needed this to work properly.

A guy answered in the OS about this :P