In the project I am currently working on we use a domain model with a quite deep nested structure of classes, code like the following is quite common.

// do something with the Address
Console.Writeline(Contract.Parties.Client.Address.Street);

The problem with this is that not all Contacts have a related Parties object and if we do have a Parties object sometimes the Client object is Null. This lead to writing a lot of code like the following:

if (Contract != Null && 
    Contract.Parties != null && 
    Contract.Parties.Client != null && 
    Contract.Parties.Client.Address != null)
{
    // do something with the Address
    Console.Writeline(Contract.Parties.Client.Address.Street);
}

There are a few problems with this code, the first of which is that it is quite verbose. Second it evaluates the same properties over and over again. In order to reduce the double work we could introduce some extra local variables and create a separate if statement for every step, this will make it even more verbose than it already is.

Of course C# 3.0 has a lot of new syntax tricks, like extension methods, lambda expressions and type inference. I had seen some nice examples (mostly Linq related) but had not been using these features to the max myself. Somehow I got the idea that these features would help me solve the Null checking problem.

I figured that the code I wanted to write was something like the following.

if (Contract
    .NullSafe(c => c.Parties)
    .NullSafe(p => p.Client)
    .NullSafe(c => c.Address) != null)
{
    // do something with the address
    Console.Writeline(Contract.Parties.Client.Address.Street);
}

The idea is that all parts of the path are expressed in separate lambda expressions which are chained together. If any link in the chain returns null, the rest of the path is never evaluated and the result of the whole expression will also be null.

All I had to do to make this possible was write one single extension method that would operate on any object, I was quite amazed that I could do this with very little code that, besides some generic stuff, was actually quite simple.

public static TResult NullSafe<T, TResult>(this T target, Func<T, TResult> func)
{
    if (target != null)
        return func(target);
    else
        return default(TResult);
}

All the generics make it look a lot more complicated than it actually is. This extension method receives two arguments, the first of which is the object it operates on and the second is a generic Func<T, TResult> delegate (the lambda expression). The return type of the extension method is automatically inferred from the return type of the lambda that is passed in. This allows you to call NullSafe again on the result of the first call and use IntelliSense to type p.Client in the second lambda.

The nice thing about extension methods is, besides that they can operate on any existing class without changing it, that they can also operate on Null references without causing a NullReferenceException!! This makes it possible to test for null inside the extension method. If the object it is called on is not null it evaluates the lambda expression and returns the result. Otherwise it returns the default value of the expected return type, for reference types this is Null.

To make life even better I created another overload of NullSafe that was even simpler:

public static void NullSafe<T>(this T target, Action<T> action)
{
    if (target != null)
        action(target);
}

Instead of a generic Func<T, TResult> delegate this one receives a Generic Action<T> delegate and returns void.

This removes the need to retype the whole path inside the if, it actually removes the if altogether.

Contract
    .NullSafe(c => c.Parties)
    .NullSafe(p => p.Client)
    .NullSafe(c => c.Address)
    .NullSafe(a =>
    {
        // do something with the address
        Console.Writeline(a.Street);
    });

Too bad for me, my current project is still on C# 2.0 so I’ll keep doing it old school style :-(

Exercise

If you would also like some practice with C# 3.0, I would like challenge you to write something that allows me to do the same thing for IEnumerable<T>, I would like to write something like the following:

foreach (Order order in Contract
    .NullSafe(c => c.Parties)
    .NullSafe(p => p.Client)
    .NullSafe(c => c.Orders))
{
    // do something with order
    Console.Writeline(o.Amount);
}

Where Client.Orders is of type IEnumerable<Order>. The idea is that I want to iterate every Order in Contract.Parties.Client.Orders. If at any stage in the path (including the Orders collection) we encounter a Null reference we will just loop an empty enumerator and do nothing.