Nullable Types in C#


A nullable Type is a data type is that contain the defined data type or the value of null.

You should note here that here variable datatype has been given and then only it can be used.

This nullable type concept is not compatible with "var".

I will explain this with syntax in the next section.


Any DataType can be declared nullable type with the help of operator "?".

Example of the syntax is as follows:

  1. int? i = null;
As discussed in previous section "var" is not compatible with this Nullable Type.

So we will have Compile Time error if we are declaring something like
  1. var? i = null;
though following syntax is completely fine

var i = 4;


Main usage of this nullable type is when we are passing any parameter to Stored Procedure or Database objects. If a column in a Table allows Null value , then in this case we should use Nullable type.

For example, say I have a Stored Procedure which accepts two in parameter @A and @B. It gives me back one out Parameter @C.

This output Parameter can be Null also. So in that case we should  use a Nullable Variable which can take Null also as allowed values.

So to conclude, Nullable Types  allows us to declare variables in .net which can be used effectively while dealing with Database.

Different Types of Operations on this Nullable Type and Expected Results

Now let us discuss in detail a few operation on these Nullable Type
  1. A Nullable Type is incompatible with a General Data Type. This means that we can not have an operation between a nullable  type and general datatype.

    For example
    1. int? x = 4;  
    2. int y = 3;  
    3. int z = x * y;  
    4. Console.WriteLine(z.ToString());  
    5. Console.ReadLine();
    Here x is nullable while y is not nullable. So The above Program will generate the following compile time Error:

    Error 1 Cannot implicitly convert type 'int?' to 'int'. An explicit conversion exists (are you missing a cast?) 

    To avoid this error we need to declare all the variables as Nullable like in following code:
    1. int? x = 4;  
    2. int? y = 3;  
    3. int? z = x * y;  
    4. Console.WriteLine(z.ToString());  
    5. Console.ReadLine();a
    This program works fine with no compile time and runtime error.
  2. In the first step, I have discussed that no operation of a nullable Type is possible with not-nullable type. But we can always compare a Nullable Type with a Not Nullable type.

    For example look at following code
    1. class Program  
    2. {  
    3.         static void Main(string[] args)  
    4.         {  
    5.             int? x = 3;  
    6.             int y = 3;  
    7.             bool check = false;  
    8.             if (x == y)  
    9.             {  
    10.                 check = true;  
    11.                 Console.WriteLine(check.ToString());  
    12.                 Console.ReadLine();  
    13.             }   
    14.         }  
    15. }
    Above code snippet works fine with no error and printing the value of check as true.
  3. The above code snippet works fine with "!=" operator also.
  4. null coalescing operator

    This operator in C# is represented as "??". Look at the following code snippet for the better understanding of this operator.
    1. class Program  
    2. {  
    3.     static void Main(string[] args)  
    4.     {  
    5.         int? x = null;  
    6.         int y = 4;  
    7.         int? result;  
    8.         result = x ?? y;  
    9.         Console.WriteLine(result.ToString());  
    10.         Console.ReadLine();  
    11.     }  
    12. }  
    Look at the statement:  result = x ?? y;

    This operator assigned the value of "x" to" result " if "x" is null else it will assign the value of "y" to "result".

    So if the first variable is null then that value will be assigned else the value of the second variable will be assigned.

    As expected in the above case "result" will hold Null.

    Caution: As variable "result" can also have null, therefore it should be defined as Nullable Type.
  5. Assigning Nullable Type variable Value to a Not Nullable Type

    Directly assigning Nullable Type Variable Value to a not Nullable Type Variable is illegal.

    Look at the following code snippet
    1. class Program  
    2. {  
    3.     static void Main(string[] args)  
    4.     {  
    5.         int? x = 4;  
    6.         int y = x;  
    7.         Console.WriteLine(y.ToString());  
    8.         Console.ReadLine();  
    9.     }  
    10. }  
    This code snippet will generate the following compile time error:

    Error 1 Cannot implicitly convert type 'int?' to 'int'. An explicit conversion exists (are you missing a cast?)

    But there is a workaround for this with the help of null coalescing operator.
    1. class Program  
    2.  {  
    3.      static void Main(string[] args)  
    4.      {  
    5.          int? x = 4;  
    6.          int y = x ?? 0;  
    7.          Console.WriteLine(y.ToString());  
    8.          Console.ReadLine();  
    9.      }  
    10.  }  
    Now if you run this program, y will have value of x i.e. 4. In place of 0 in statement int y = x ?? 0;, you can use any integer.

    Whatever the integer you use will be the default value of "y".
I will be writing more about nullable Types in my next article.

Hope it helps the reader.