Write thoughtful code, write meaningful code, become a legend: Throwing exceptions

Introduction

Exceptions play an important role in a well designed and maintainable piece of code. One of the primary reasons for their existence is mainly out of declarative reasons and in order to manifest clarity. Before there were exceptions, for decades developers poisoned deep-nested-if-then-else-code-blocks by injecting additional control flow for error checking and handling. They wrote functions that did not return the result of the single task they were meant to accomplish, but instead returned a dubious integer coded error state that was then also hardwired into the jungle of predicates.

This not only lead to severe cases of hair loss, digestion disorders and aggressive behavior among the developers, but as a direct result produced tons of obfuscated legacy code that costs the industry billions each year and still does. Malicious gossip has it that this may also secure a lot of jobs. Be that as it may:

A good developer always throws an exception if a check of a critical precondition fails and before the poisoned blood reaches the very heart of the algorithm. In other less poetic words: Sh!% in and even more sh!% will come out of it.

Secondly, but even more important for creating maintainable code, exceptions provide a powerful tool to enhance the declarative flow of your code. A thoughtful placement of an exception elegantly fits into good structured code and renders additional code comments redundant. If used consequently this greatly helps the maintainer to understand your thoughts while not distracting him or her from the job of understanding or even purifying your work.

At the end and because I am a practitioner. I want to supply you with some extension methods that I tend to use often when throwing exceptions. Even though extension methods can also lead to evil obfuscation of code, I think they can be quite a nice tool in this area. Enjoy!

Using the code

Consider the following code snippet which makes use of the extension methods below:

public abstract class StateMachineBase<TStateEnum> : IStateMachine<TStateEnum> where TStateEnum : struct
{
	static StateMachineBase ()
    {
    	typeof(TStateEnum).IsEnum.NoThenThrow<ArgumentException>("The type parameter must be of type: {0}", typeof(Enum));
	}
...

public static class ExceptionExtensionsMethods
{
	[DebuggerStepThrough]
	public static void YesThenThrow<T>(this bool predicate, string message, params object[] messageArguments) where T : Exception
	{
	  	if (predicate)
	  	{
	    	var exception = String.IsNullOrEmpty(message) 
	    		? (T) Activator.CreateInstance(typeof (T), true)
	    		: (T) Activator.CreateInstance(typeof (T), String.Format(message, messageArguments));

	    	throw exception;
	  	}
	}

	[DebuggerStepThrough]
	public static void NoThenThrow<T>(this bool predicate, string message, params object[] messageArguments) where T : Exception
	{
	  	if (predicate == false)
	  	{
	    	var exception = String.IsNullOrEmpty(message) 
	    		? (T) Activator.CreateInstance(typeof (T), true)
	    		: (T) Activator.CreateInstance(typeof (T), String.Format(message, messageArguments));

	    	throw exception;
	  	}
	}
}

Points of Interest

Please be aware that while the extension methods provide a declarative way of throwing an exception, you pay the cost of one additional frame in the resulting stack trace.

History

1.0 Initial version