Null Object Design Pattern

Introduction

 

In this article, we discuss the null object design pattern. 

 

Why do we need this pattern?

 

We all are familiar with null checks. The greater the number of null checks, the more the cyclomatic complexity. With the help of a null object design pattern, we can finally start bringing some sense to our null checks.

 

Let's start with a client class, which keeps the track of which smartPhone to sell. If SomeSmartPhoneMethod() returns nothing then SmartPhone class's object will be null.

 

In this case, the code might throw a null exception to the user.

class SmartPhoneSale
 {
     SmartPhone OnePlus8 = SomeSmartPhoneMethod();

     static void Main(string[] args)
     {
         if (OnePlus8 == null)
         {
             throw new ArgumentNullException();
         }
     }
 }

Let's see how it looks conceptually:

 

 

As per our concept, we have already implemented a client class: SmartPhoneSale.

 

Now we need abstraction in our code. Let's go ahead and create that interface. 

using System;
using System.Collections.Generic;
using System.Text;

namespace NullObjectDesignPattern
{
    public interface ISmartPhone
    {
        string Name { get; }

        double Price { get; }
    }
}

We need to concrete classes. One is for default initialization and another for our logic.

 

Let's create default class.

using System;
using System.Collections.Generic;
using System.Text;

namespace NullObjectDesignPattern
{
    class DefaultSmartPhone : ISmartPhone
    {

        public string Name { get => "Please select smart phone first"; }
        public double Price { get => 0; }
    }
}

As you can see, we are doing nothing here, other than just assigning an object to do something when it goes into null state.

 

Basic implementation

using System;
using System.Collections.Generic;
using System.Text;

namespace NullObjectDesignPattern
{
    public class SmartPhone : ISmartPhone
    {
        public SmartPhone(string Name, double price)
        {
            this.Name = Name;
            this.Price = price;
        }
        public string Name { get; }

        public double Price { get; }
    }
}

We are all set, Now let's make a few changes in the client class:

using System;

namespace NullObjectDesignPattern
{
    class SmartPhoneSale
    {
        private static SmartPhone SmartPhoneInstance;//= new SmartPhone("OnePlus8Pro", 55000);

        static void Main(string[] args)
        {
            ISmartPhone BrandNewPhone = SmartPhoneInstance;
            if (BrandNewPhone == null)
            {
                BrandNewPhone = new DefaultSmartPhone();
            }
            Console.WriteLine($"Phone: {BrandNewPhone.Name},  Price: {BrandNewPhone.Price}");
        }
    }
}

As you can see, when the object for smartPhone is null, we are assigning him default class's instance.

 

Beautiful.

 

Output when you did not initialize a smartPhoneInstance:

 

 

Output when you initialize a SmartPhoneInstance. Just uncomment the line above.

 

 

This is the simplest design pattern to implement. It is a good practice to work with design patterns. It gives you a broad idea on object communications.

 

Feel free to download the attached source code for your reference.

 

I sincerely hope that you enjoyed this blog and that you're inspired to apply what you've learned to your own applications.

 

Happy coding.

 

Connect with me:

• GitHub
• Linkedin