Question

Do you prefer checked exception handling like in Java or unchecked exception handling like in C# and why?

Answer 1

Meh.

Checked exceptions are a great thing when used properly, but more often than not they lead to stuff like:

doSomething();
try
{
  somethingThrowsCheckedException();
}
catch(ThatCheckedException)
{ }
doSomethingElse();    

And, frankly, that’s just wrong. You should let exceptions you don’t handle bubble up.

Checked exceptions used properly can be good. But very frequently, the result of doing checked exceptions properly is method signatures like this:

public void itMightThrow() throws Exception1, Exception2, Exception3, Exception4, // ...
Exception12, Exception13, /* ... */ Exception4499379874
{
  // body
}

Am I exaggerating? Only slightly.

Edit:

That said, one thing I prefer about C# over Java when it comes to exception handling has nothing to do with checked exceptions (I can get that if I go with Spec# anyway). No, what I like is that the stack trace in C# is populated when you throw an exception, rather than when you instantiate one as it is in Java.

Edit 2: This is for the commenters @Yishai, @Eddie, @Bill K:

First, you should check out this thread for information on how to get a stack trace without instantiating an exception. Keep in mind that walking the stack is a heavy process and should not be done on a regular basis.

Second, the reason I like C#’s exception stack trace being populated at throwal rather than at instantiation is that you can do things like this:

private MyException NewException(string message)
{
   MyException e = new MyException(message);
   Logger.LogException(message, e);
   return e;
}

// and elsewhere...
if(mustThrow)
{
   throw NewException("WHOOOOPSIEE!");
}

That’s a trick you can’t do in Java without having the NewException method included in the stack trace.