// do something with the Adress
Console.Writeline(Contract.Parties.Client.Adress.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 code like the following:
if (Conract != Null &&
Contract.Parties != null &&
Contract.Parties.Client != null &&
Contract.Parties.Client.Adress != null)
{
// do something with the Adress
Console.Writeline(Contract.Parties.Client.Adress.Street);
}
There are a few problems with this code, the first of which is that it is quit 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 separete if statement for every step, this will make it even more verbose than it is allready.
Of course C# 3.0 has a lot of new syntax tricks, like extension methods, lambda expression 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 adress
Console.Writeline(Contract.Parties.Client.Adress.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 verry little code that, besides some generic stuff, was actually quite simple.
public static TResult NullSafe
{
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
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
{
if (target != null)
action(target);
}
Instead of a generic Func
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 adress
Console.Writeline(a.Street);
});
To 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
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