Question

I know two approaches to Exception handling, lets have a look at them.

1. Contract approach.

   When a method does not do what it says it will do in the method header, it will throw an exception. Thus the method "promises" that it will do the operation, and if it fails for some reason, it will throw an exception.

2. Exceptional approach.

   Only throw exceptions when something truly weird happens. You should not use exceptions when you can resolve the situation with normal control flow (If statements). You don’t use Exceptions for control flow, as you might in the contract approach.

Lets use both approaches in different cases:

We have a Customer class that has a method called OrderProduct.

contract approach:

class Customer {      public void OrderProduct(Product product)      {            if((m_credit - product.Price) < 0)                   throw new NoCreditException("Not enough credit!");            // do stuff       } } 

exceptional approach:

class Customer {      public bool OrderProduct(Product product)      {           if((m_credit - product.Price) < 0)                    return false;           // do stuff           return true;      } }  if !(customer.OrderProduct(product))             Console.WriteLine("Not enough credit!"); else    // go on with your life 

Here I prefer the exceptional approach, as it is not truly Exceptional that a customer has no money assuming he did not win the lottery.

But here is a situation I err on the contract style.

Exceptional:

class CarController {      // returns null if car creation failed.      public Car CreateCar(string model)      {          // something went wrong, wrong model          return null;      }  } 

When I call a method called CreateCar, I damn wel expect a Car instance instead of some lousy null pointer, which can ravage my running code a dozen lines later. Thus I prefer contract to this one:

class CarController {            public Car CreateCar(string model)      {          // something went wrong, wrong model          throw new CarModelNotKnownException("Model unkown");           return new Car();      }  } 

Which do style do you use? What do you think is best general approach to Exceptions?

Answer 1

I favor what you call the ‘contract’ approach. Returning nulls or other special values to indicate errors isn’t necessary in a language that supports exceptions. I find it much easier to understand code when it doesn’t have a bunch of ‘if (result == NULL)’ or ‘if (result == -1)’ clauses mixed in with what could be very simple, straightforward logic.