Nullable Types in C#: Basic Introduction

public struct student{
    private int m_RollNumber; // Can range from 0 -- 100
    private string m_FullName ; // the non blank string name.
    ..
    ..
    public student( int RollNumber, string FullName,.....){
    //Initialize the members of the new object
    this.m_RollNumber = RollNumber ;
    this.m_FullName = FullName;
    ..
    ..
}

public class Students
{
    //The Internal array list maintaining the student list
    private ArrayList m_Students = new ArrayList(100);
    public Student GetStudentInfo(int RollNumber){
        //Iterate through the list to find the student with roll number RollNumber
        foreach( student stTemp in m_Students){
            //Check if the stTemp is the required student.
            If( stTemp.m_RollNumber == RollNumber){
                //if yes return the stTemp.
                Return stTemp ;
            }
        }
        //If no match found return the empty object.
        Return new Student();
    }
}

The implementation of this function will return an object of the Student structure in all the cases even though the function fails to find the particular student[Since returning a blank object is done to suppress the compiler error.]. The caller of the function is still in ambiguity of the validity of the value returned. This is due to the fact that we can never assign the "null" value to the value type object.

To work around this problem we need to go for the 'Out' parameters. The modified version of the function is as follows:

public bool GetStudentInfo( int RollNumber, out Student outStudent){
    //Initialize the outStudent object to a blank object.
    outStudent = new Student();
    //Iterate through the loop to find the student with roll number as RollNumber
    foreach( student stTemp in m_Students)
    {
        If( stTemp.m_RollNumber == RollNumber)
        {
            //If the required object found then
            //Save it to the out parameter and
            outStudent = stTemp ;
            //return true to indicate the success.
            Return true;
        }
    }
    //If object is not found then simply return the false to denote the failure
    Return false;
}

By calling this version of the function the caller has a way to find the validity of the returned object and in turn to check the success of the function execution through the returned Boolean value. However changing the function signature this way makes the function hard to understand and call.

To overcome the above mentioned problems with the default value and the return value from the function. We need some tactful way around this problem.

That's the reason Microsoft has introduced the Nullable Types in the C# 2.0.

b. What are the Nullable types?

Nullable Types are the same generic data type with a wrapper structures written around the generic data type. This wrapper structures allow assigning the value "null" to the value type objects even.

If any object of the generic type has the '?' attached to the data type while declaring the value object. It denotes the object is a Nullable object of that data type e.g. if I declare the RollNumber as

int? RollNumber = null ;

The RollNumber declared above is Nullable roll number that means assigning the value null to the Rollnumber is valid and completely acceptable. This reduces the burden to make some value as default and also since the function can return the Nullable types as a return type we have a way to return a null value through the object when the function fails.

An instance of the Nullable type has two public properties.

• HasValue - A Boolean property denoting the validity of the value contained in the object.
• Value - A value contained in the object.

The 'true' value for the HasValue property guarantees the validity of the value contained in the object which can be accessed through the Value property. A 'false' value for the HasValue indicates the invalid value contained by the object suggesting not to use the Value property.

An instance for which HasValue is false is said to be null. A null instance has an undefined value. Attempting to read the Value of a null instance causes a System.InvalidOperationException to be thrown.

Taking about the default values for the Nullable type we can say; Any instance of a Nullable type is said to have a default value when the HasValue is set to 'false' and the value property is undefined. This value is known as an null value of an Nullable type. While implicitly converting the 'null' value to any nullable type values the conversion results in the null value of the nullable type.

The following example shows the use of the Nullable type.

class Program
{
    //the Nullable Roll number.
    public int? RollNumber = null;
    static void Main(string[] args)
    {
        Program pTemp = new Program();
        //use the public member.
        pTemp.RollNumber = 100;
        //Write to console to check the object values.
        Console.WriteLine("Value in RollNumber is:{0} ,[HasValue]{1}", pTemp.RollNumber.Value, pTemp.RollNumber.HasValue);
        //test using the null.
        pTemp.RollNumber = null;
        Console.WriteLine("Value in RollNumber is:{0} ,[HasValue]{1}", pTemp.RollNumber.Value, pTemp.RollNumber.HasValue); //This line throws and InValidOperationException.
    }
}

Some rules govern the type conversion between the Nullable and non-Nullable types this will be covered in the next articles [With a modified version of the GetStudentInfo function].