Question

I’m kind of torn between these two error-handling models:

1. Create a boolean Error and a string ErrorMessage property for your object. Catch all exceptions internally in the object’s methods and pass the messages along using conditional logic from the caller, ie:

   Dim o As New MyObject
   o.SomeMethod()
   If Not o.Error Then
       'Do stuff'
   Else
       Dim msg As String = o.ErrorMessage
       'do something with message'
   End If
   

2. Throw exceptions in your object and handle them on the outside with Try Catch logic:

   Dim o As New MyObject
   Try
      o.SomeMethod()      
      'Do stuff'
   Catch ex As Exception
       Dim msg As String = ex.ErrorMessage
       'do something with message'
   End Try
   

To me, it seems like the same amount of code either way, except that you have property code for the Error and ErrorMessage properties. However, you also can tell when an error occurs without having to check for exceptions. Which pattern should I go with?

Answer 1

I recommend using both.

Why?

“Use the right tool for the job”

The “problem” with return codes is that people often forget to handle them. However, exceptions don’t solve this problem! People still don’t handle exceptions (they don’t realise a certain exception needs to be handled, they assume somebody up the stack will handle it, or they use a catch() and squash all errors).

While an unhandled return code might mean the code is in an unstable state, an unhandled exception often guarantees that the program will crash. Is this better?

While a return code is easily identifiable when writing code, it is often impossible (or just tediously time-consuming) to determine what exceptions might be thrown by a method you are calling. This typically results in a lot of very poor exception handling.

Exceptions are supposed to be used for “errors”. Therein lies the difficulty. If a file is not found when you try to open it, is that an “error”, or an “expected situation”? Only the caller knows. Using exceptions everywhere essentially elevates every piece of status information into an error.

Ultimately, error handling is something a programmer has to work at. This problem exists in both return codes and exceptions.

Thus, I use return codes for passing status information (including “warnings”), and exceptions for “serious errors”. (and yes, sometimes it’s hard to judge which category something falls under)

Example case from .net:

Int32.Parse throws exceptions (even though none of its exceptions are errors – it is up to the caller to verify the results and decide for themselves if the result is valid). And it’s simply a pain (and a performance hit) to have to enclose every call to it in a try/catch. And if you forget to use a try/catch, a simple blank text entry field can crash your program.

Thus, Int32.TryParse() was born. This does the same thing, but returns an error code instead of an exception, so that you can simply ignore errors (accepting a default value of 0 for any illegal inputs). In many real life situations this is much cleaner, faster, easier and safer to use than Int32.Parse().

“TryParse” uses a naming convention to make it clear to the caller that errors might occur, that should be correctly handled. Another approach (to force programmers to handle errors better) is to make the return code into an out or ref parameter, so that the caller is explicitly made aware of the need to handle returned errors.