NULL Objects?

// as noted here: http://dl.dropbox.com/u/7810909/docs/patterns/patterns/html/index.html#IntroduceNullObject

if (customer == null)
    plan = BillingPlan.basic();
else
    plan = customer.getPlan();

First let it be noted that this is essentially a violation of Tell-Don't ask.
I am fiddling with the privates of customer (his plan). But since
nothing else is given, I will stay in the context.

My idea of a NULL Object might become clearer when more scope is visible.


The customer must come from somewhere. Let's imagine something like a DB access:



// The customer needs to come from somewhere
var customer = customer.named('Petersen');

if (customer == null)
    plan = BillingPlan.basic();
else
    plan = customer.getPlan();

// Something needs to happen with the plan object.
_billingService.Magic(plan);


If the object is null, this would say that the pointer is targeting a nonexisting adress and the object does not exist. What we are trying to convey though is that the coustomer could not be found. I feel that neither option nor x == null really capture this information.
So the idea of the null object is, that a polymorphic object will be returned. This could behave as follows:

class NoCustomerFound : Customer
{
    public NoCustomerFound(string name)
    {
        // If this object exists it's due to some semantic error
        // This could be handled in here. The ctor could log these cases
        Logger.log('A customer with the name of ' + name + 'does not exist. ');
    }

    public Plan getPlan()
    {
        // Handle here why this exists.

        return BillingPlan.basic();
    }
}


var customer = customer.named('Petersen');
customer.getPlan();
_billingService.Magic(plan);


Like this it is guaranteed that there is always a customer. If at some point the existence of a null is allowed all adjacent functions using it would have to reimplement the nullcheck. The special object makes the special error case an explicit part of the domain and gives us one single point of change, where we can handle this case.
This prevents nullchecks all over the place and allows for semantics that are close to our actual domain.