Bug?! throw vs. throw ex

[GoogleNewsReaderMan]

I want to "rethrow" an exception so as not to lose the original stack
trace information. I understood that I could use throw, like:

try {
DoIt();
}
catch (Exception ex) {
DoSomeException Stuff(ex);
throw;
}
However, this apparently does NOT preserve the stack trace--it loses it
just like using throw ex; does! I am currently using .NET 1.1 SP1. Is
this a known bug? Why do so many people report that it works for them?
Have they actually tried it?

Why would a bug like this exist in v. 1.1 SP1?
Can anyone help shed some light on this?

Thanks in advance.

[Alvin Bruney [MVP]]

the rethrow does not preserve the stack. it is not a bug. You need preserve
the stack and then throw a new exception with the amended stack

--
Regards,
Alvin Bruney [MVP ASP.NET]

[Shameless Author plug]
The Microsoft Office Web Components Black Book with .NET
Now Available @ http://tinyurl.com/27cok
----------------------------------------------------------
"GoogleNewsRead erMan" <lo***********@ hotmail.com> wrote in message
news:11******** *************@c 13g2000cwb.goog legroups.com...

I want to "rethrow" an exception so as not to lose the original stack
trace information. I understood that I could use throw, like:

try {
DoIt();
}
catch (Exception ex) {
DoSomeException Stuff(ex);
throw;
}
However, this apparently does NOT preserve the stack trace--it loses it
just like using throw ex; does! I am currently using .NET 1.1 SP1. Is
this a known bug? Why do so many people report that it works for them?
Have they actually tried it?

Why would a bug like this exist in v. 1.1 SP1?
Can anyone help shed some light on this?

Thanks in advance.

[MarkT [developmentor]]

> I want to "rethrow" an exception so as not to lose the original stack

trace information.

I believe the stack trace is populated as part of the throw, not when the
exception object is created.

Create a new exception and stuff the old one inside it as the "inner
exception". The new one should have the new stack trace and the old one the
original stack trace.

[Jako Menkveld]

Not sure if it works, but try

throw new Exception("some message", ex)

"GoogleNewsRead erMan" <lo***********@ hotmail.com> wrote in message
news:11******** *************@c 13g2000cwb.goog legroups.com...

I want to "rethrow" an exception so as not to lose the original stack
trace information. I understood that I could use throw, like:

try {
DoIt();
}
catch (Exception ex) {
DoSomeException Stuff(ex);
throw;
}
However, this apparently does NOT preserve the stack trace--it loses it
just like using throw ex; does! I am currently using .NET 1.1 SP1. Is
this a known bug? Why do so many people report that it works for them?
Have they actually tried it?

Why would a bug like this exist in v. 1.1 SP1?
Can anyone help shed some light on this?

Thanks in advance.

[David Levine]

Yes, it's a bug. It is supposed to be fixed in Whidbey. For now you will
need to wrap the exception in a new exception object and use the original
exception as the inner exception.

"GoogleNewsRead erMan" <lo***********@ hotmail.com> wrote in message
news:11******** *************@c 13g2000cwb.goog legroups.com...

I want to "rethrow" an exception so as not to lose the original stack
trace information. I understood that I could use throw, like:

try {
DoIt();
}
catch (Exception ex) {
DoSomeException Stuff(ex);
throw;
}
However, this apparently does NOT preserve the stack trace--it loses it
just like using throw ex; does! I am currently using .NET 1.1 SP1. Is
this a known bug? Why do so many people report that it works for them?
Have they actually tried it?

Why would a bug like this exist in v. 1.1 SP1?
Can anyone help shed some light on this?

Thanks in advance.

[Jon Skeet [C# MVP]]

<"Alvin Bruney [MVP]" <vapor at steaming post office>> wrote:

the rethrow does not preserve the stack. it is not a bug. You need preserve
the stack and then throw a new exception with the amended stack

Not true. Try this:

using System;

class Test
{
static void Main()
{
try
{
DoSomething();
}
catch (Exception e)
{
Console.WriteLi ne (e);
}
}

static void DoSomething()
{
try
{
DoSomethingNaug hty();
}
catch (Exception)
{
throw;
}
}

static void DoSomethingNaug hty()
{
string x = null;
bool y = x.Equals("hello ");
}
}

Compile it with debug turned on and run it. I get a stack trace of:
System.NullRefe renceException: Object reference not set to an instance
of an object.
at Test.DoSomethin gNaughty() in c:\test\Test.cs :line 32
at Test.DoSomethin g() in c:\test\Test.cs :line 25
at Test.Main() in c:\test\Test.cs :line 9

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Helge Jensen]

Jako Menkveld wrote:

Not sure if it works, but try

throw new Exception("some message", ex)

That would give you a new exception, with this place as stack-trace and
the old exception (with the old stack-trace) as it's "Inner" exception.

I have come to almost loathe the above way of coding, since it means
that catchers cannot use the type of the exception to dispatch to a
catch-handler but has to catch Exception and to analysis on the content
of e.Inner.

This is especially interesting with Delegate, which throws a wrapped
exception if invoking the Delegate throws an exception (/me holds back a
swarm of swearwords).

The difference between "throw e;" and "throw;" is that "throw;" rethrows
the original catch'ed exception unchanged (like in C++) whereas "throw
e"; throws the expression e, which happens to refer to a catch'ed
exception object.

--
Helge

[Alvin Bruney [MVP]]

I get the same results as you. I stand corrected.

--
Regards,
Alvin Bruney [MVP ASP.NET]

[Shameless Author plug]
The Microsoft Office Web Components Black Book with .NET
Now Available @ http://tinyurl.com/27cok
----------------------------------------------------------
"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...

<"Alvin Bruney [MVP]" <vapor at steaming post office>> wrote:

the rethrow does not preserve the stack. it is not a bug. You need
preserve
the stack and then throw a new exception with the amended stack

Not true. Try this:

using System;

class Test
{
static void Main()
{
try
{
DoSomething();
}
catch (Exception e)
{
Console.WriteLi ne (e);
}
}

static void DoSomething()
{
try
{
DoSomethingNaug hty();
}
catch (Exception)
{
throw;
}
}

static void DoSomethingNaug hty()
{
string x = null;
bool y = x.Equals("hello ");
}
}

Compile it with debug turned on and run it. I get a stack trace of:
System.NullRefe renceException: Object reference not set to an instance
of an object.
at Test.DoSomethin gNaughty() in c:\test\Test.cs :line 32
at Test.DoSomethin g() in c:\test\Test.cs :line 25
at Test.Main() in c:\test\Test.cs :line 9

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[GoogleNewsReaderMan]

One arguable flaw here, though, is that you lose the location within
the DoSomething() method --- the line number is that of the throw. So,
in fact, the stack trace is modified, and not that of the original
exception.
Jon wrote:

<"Alvin Bruney [MVP]" <vapor at steaming post office>> wrote:

the rethrow does not preserve the stack. it is not a bug. You need preserve the stack and then throw a new exception with the amended stack
Not true. Try this:

using System;

class Test
{
static void Main()
{
try
{
DoSomething();
}
catch (Exception e)
{
Console.WriteLi ne (e);
}
}

static void DoSomething()
{
try
{
DoSomethingNaug hty();
}
catch (Exception)
{
throw;
}
}

static void DoSomethingNaug hty()
{
string x = null;
bool y = x.Equals("hello ");
}
}

Compile it with debug turned on and run it. I get a stack trace of:
System.NullRefe renceException: Object reference not set to an

instance of an object.
at Test.DoSomethin gNaughty() in c:\test\Test.cs :line 32
at Test.DoSomethin g() in c:\test\Test.cs :line 25
at Test.Main() in c:\test\Test.cs :line 9

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[danielshanyfelt]

Gentlemen,

There seem to be a lot of experts replying to this thread so I will add
my own question. If you wanted to get the same exception at a higher
level, why would you catch it at all?

for example (modifying the previous code):

using System;

class Test
{
static void Main()
{
try
{
DoSomething();
}
//handle all exceptions without bias on moral behavior
catch (Exception e)
{
Console.WriteLi ne (e);
}
}

static void DoSomething()
{
try
{
DoSomethingNaug hty();
}
catch (NaughtyExcepti on)
{
//handle the offending problem
}
//let all of the less ethicly challenged exceptions bubble up
the the calling Main()
}

static void DoSomethingNaug hty()
{
string x = null;
bool y = x.Equals("hello ");
}
}

If I wanted to do some intermediate processing in the routine and then
still post an error to the calling method, I would throw a new
exception (of whatever type) with the original exception as the inner
exception. Does stuffing the old exception into the new still mess up
the stack?

Thanks,
Dan