this post was submitted on 17 Jun 2023
144 points (96.8% liked)
Programmer Humor
32595 readers
1789 users here now
Post funny things about programming here! (Or just rant about your favourite programming language.)
Rules:
- Posts must be relevant to programming, programmers, or computer science.
- No NSFW content.
- Jokes must be in good taste. No hate speech, bigotry, etc.
founded 5 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
Lol what’s wrong with this if the parent function catches it
If this is C# (and it looks like it is), this leads to you losing the original stack trace up until this point.
The correct way to do this in C# is to just
throw;
after you're done with whatever you wanted to do in thecatch
.wait what ?
So you are saying that the following code will keep throwing
e
but if I usedthrow e;
it would basically be the same except for the stack trace that would be missing the important root cause ?!Exactly. Aside from deleting your already built stack trace, as a bonus you'll get another stack trace building call, enjoy wasted CPU cycles.
Depending on the language it either does nothing and just adds code bloat or (and this would be much worse) it will catch any exception that can be implicitly cast to type Exception and throw it as type Exception. So the next higher scope would not be able to catch e.g. a RuntimeException or w.e. to handle appropriately. It could only catch a regular Exception even if the original error was a more detailed type.
It's C# so it's just rethrowing the original exception.
It might also be messing with the stack trace though which can be a bit frustrating for future debugging. But that's only a vague recollection of something I read in the past so I could be wrong
Throwing exceptions are very costly due to the stack trace, so building the stack trace twice will cause a big performance hit
Correct me if I'm wrong, but this will actually cut the stack trace and then start another one from your try-catch block, which is an evil thing to do towards those who will actually read your stack traces. To preserve the stack trace you do
throw;
, notthrow ex;
, and I'm assuming IDE is underlining that statement exactly for this reason.Yes, hence why I mentioned it collects the stack trace twice.
It's more than just more difficult for debugging
The
catch
is useless if it's just throwing the exception anywayThe catch is mandatory...
You don't catch it if that's the case
You could just not catch it and it'll get thrown up the stack anyway.
Then the parent function would catch the original exception if it was never caught in the first place. All this does is bork the stacktrace.