C# exceptions and rethrow

[saxenark]

In the program below, I expected to have the line "throw new Exception("A")" also reported when I dump the exception object in Main. Unfortunately, this information is being lost even though I am doing a rethrow using throw;. Two questions:

a) Why is this behavior when throw; is supposed to preserve call stack?
b) What is the recommended way to handle this across different versions of C# and .NET?

using System;

namespace DBConnect
{
    class Program
    {
        static void f()
        {
            try
            {
                g();
            }
            catch(Exception e)
            {
                e.ToString();
                //throw new Exception("f", e);
                throw;
            }
        }

        static void g()
        {
            try
            {
                throw new Exception("A");   // this line does not show up in call trace
            }
            catch(Exception e)
            {
                e.ToString();
                //throw new Exception("g", e);
                throw;
            }
        }

        static void Main(string[] args)
        {
            try
            {
                f();
            }
            catch(Exception e)
            {
                Console.WriteLine(e.StackTrace);
                Console.WriteLine(e.ToString());
            }
        }
    }
}

[mikedn]

a) Why is this behavior when throw; is supposed to preserve call stack?

Well, throw; (rethrow in IL) is supposed to preserve the original call stack but it also adds itself to the call stack. But in your g() method throw and rethrow are in the same method. The line number information is recorded per stack frame and there's only one stack frame for a method. So rethrow practically overwrites the line number information that throw generates.

b) What is the recommended way to handle this across different versions of C# and .NET?

I'm not aware of a way to avoid this. Besides, this is not specific to any particular version of C# and .NET, to the best of my knowledge all behave like this since day 1.

Personally I avoid this kind of code whenever possible. Not necessarily because line number information is lost because I find it weird to throw an exception and then catch and rethrow it just below. But of course, it's not always possible to avoid this kind of code in a reasonable fashion.

[danmoseley]

Does ExceptionDispatchInfo help - example dotnet/corefx#14249

[mikedn]

Hmm, looks like it could help, it doesn't produce the exact same stack trace that a "proper" rethrow would produce but at least it contains both locations:

        static void g()
        {
            try
            {
                throw new Exception("A");   // line 26
            }
            catch (Exception e)
            {
                e.ToString();
                ExceptionDispatchInfo.Capture(e).Throw();  // line 31
            }
        }

generates

   at DBConnect.Program.g() in c:\users\mike\Desktop\Temp\Projects\ConsoleApp4\Program.cs:line 26
--- End of stack trace from previous location where exception was thrown ---
   at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw()
   at DBConnect.Program.g() in c:\users\mike\Desktop\Temp\Projects\ConsoleApp4\Program.cs:line 31
   at DBConnect.Program.f() in c:\users\mike\Desktop\Temp\Projects\ConsoleApp4\Program.cs:line 18
   at DBConnect.Program.Main(String[] args) in c:\users\mike\Desktop\Temp\Projects\ConsoleApp4\Program.cs:line 39

[saxenark]

I think I finally found the issue documented very clearly in MSDN

The common language runtime (CLR) updates the stack trace whenever an exception is thrown in application code (by using the throw keyword). If the exception was rethrown in a method that is different than the method where it was originally thrown, the stack trace contains both the location in the method where the exception was originally thrown, and the location in the method where the exception was rethrown. If the exception is thrown, and later rethrown, in the same method, the stack trace only contains the location where the exception was rethrown and does not include the location where the exception was originally thrown.

I just wish it was part of the throw; msdn documentation so that it is easier to co-relate.

[gkhanna79]

@saxenark Can this be closed?

[saxenark]

Yes, please close this. Thanks.

[danmoseley]

https://github.com/dotnet/coreclr/issues/15780