Articles → .NET DESIGN PATTERN → Null object Design Pattern

Null object Design Pattern

Null object design pattern is a very useful design pattern which every developer should know. The use of this design pattern makes the code less error prone. In this tutorial I will explain a scenario in which we can use this pattern.

Scenario

Consider a database table which contains the information about the members of the website.

There can be numerous columns in the table but for the sake of this tutorial we are keeping it very simple. So in the table there will be only three fields i.e. MemberId, MemberName and MemberEmailId.

Now to get the information about the member I am creating a simple function which fetches the information on the basis of member Id

public MemberEntity GetMemberInformation(int memberId){}

See the return type of the function, this function returns the MemberEntity. MemberEntity is a class that contains three properties i.e. Id, FullName and Email.

public class MemberEntity
{
    private int _Id;
    private string _FullName;
    private string _Email;
    public int Id
    {
        get
        {
            return _ Id;
        }
        set
        {
            _ Id = value;
        }
    }
    public string FullName
    {
        get
        {
            return _ FullName;
        }
        set
        {
            _ FullName = value;
        }
    }
    public string Email
    {
        get
        {
            return _ Email;
        }
        set
        {
            _ Email = value;
        }
    }
}

Now let us go back to the method GetMemberInformation, let us write some code to get the information about a member

public MemberEntity GetMemberInformation(int memberId)
{ 
 	 DataSet userInformationDataSet;
  	SQLServer obj;
  	MemberEntity memberEntityObject = null;
  	userInformationDataSet = obj.GetResultSet(query);
  	if (userInformationDataSet != null)
  	{
		  if (userInformationDataSet.Tables.Count > 0)
		  {
        if (userInformationDataSet.Tables[0].Rows.Count > 0) 
		    {
			    memberEntityObject = new MemberEntity();
          //  Code to set the value into entity properties 
        } 	
      }
    }
    return memberEntityObject;
}

As you can see in the code there are so many if conditions which are required so that we can make the code less error prone. But there are few scenarios missed in the code like what will happen if dataset is null or there is no table exist in the dataset or there is no record in the table. So in that case the variable memberEntityObject returns null. So the programmer have to check the code for null everytime whenever he is using this function.

But what will happen if the programmer forget to check the null then there is a possibility of run time error in the system. So here we can use null object design pattern.

Null object design pattern

Consider the MemberEntity class again and modify the code to deal with the scenario.

• Create a private class inside the MemberEntity class that is inherited from MemberEntity class.

private class NullMemberEntity : MemberEntity
{
        public override int Id
        {
            get
            {
                return 0;
            }
        }

        public override string FullName
        {
            get
            {
                return string.Empty;
            }
        }

        public override string Email
        {
            get
            {
                return string.Empty;
            }
        }
}

• Create the static instance of the class inside the MemberEntity class.

public static readonly MemberEntity NULL = new NullMemberEntity();

• Make the properties in the MemberEntity class virtual

So the definition of MemberEntity class would be

public class MemberEntity
{
    public static readonly MemberEntity NULL = new NullMemberEntity();

    private int _Id;
    private string _FullName;
    private string _Email;
    #endregion
   
    public MemberEntity()
    {
        //
        // TODO: Add constructor logic here
        //
    }

    public virtual int Id
    {
        get
        {
            return _Id;
        }
        set
        {
            _Id = value;
        }
    }

    public virtual string FullName
    {
        get
        {
            return _ FullName;
        }
        set
        {
            _ FullName = value;
        }
    }
    public virtual string Email
    {
        get
        {
            return _ Email;
        }
        set
        {
            _ Email = value;
        }
    }
    
    private class NullMemberEntity : MemberEntity
    {
        public override int Id
        {
            get
            {
                return 0;
            }
        }

        public override string FullName
        {
            get
            {
                return string.Empty;
            }
        }

        public override string Email
        {
            get
            {
                return string.Empty;
            }
        }
    }
}

Now in the GetMemberInformation function instead of initializing the object by null we can initialize it with NULL which is the static instance of the new class.

public MemberEntity GetMemberInformation(int memberId)
{ 
 	  DataSet userInformationDataSet;
  	SQLServer obj;
  	MemberEntity memberEntityObject = MemberEntity.NULL;
  	userInformationDataSet = obj.GetResultSet(query);
  	if (userInformationDataSet != null)
  	{
		  if (userInformationDataSet.Tables.Count > 0)
		  {
        if (userInformationDataSet.Tables[0].Rows.Count > 0) 
		    {
			    memberEntityObject = new MemberEntity();
          //  Code to set the value into entity properties 
        }	
  		}
    }
    return memberEntityObject;
}

So the programmer don’t need to check for null. And the code is less error prone.

Posted By -	Karan Gupta

Posted On -	Tuesday, August 30, 2011

Query/Feedback

Your Email Id

Subject

Query/Feedback	Characters remaining 250