Definition

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 comaptible with "var".

I will explain this with syntax in next section.

Declaration:

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

Example of the syntax is as Follows :-

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 :-

var? i = null;

though  following syntax is completely fine :-

var i = 4;

Usage :

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 Dotnet which can be used effectively while dealing with Database.

Different Types of Operations on this Nullanle Type and Expected Results :-

Now let us discuss in detail few operation on these Nullable Type :-

1. A Nullable Type is incompatible  with a Genaral Data Type. This means that we can not have an operation between a nullable  type and general dtatype.
   
   For example :-
   
               int? x = 4;
               int y = 3;
               int z = x * y;
               Console.WriteLine(z.ToString());
               Console.ReadLine();  
   
   Here x is nullable while y is not nullable . So The above Program will generate 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 :-
        
               int? x = 4;
               int? y = 3;
               int? z = x * y;
               Console.WriteLine(z.ToString());
               Console.ReadLine();a
   
   This program works fine with no compile time and run time 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 Follwing Code :-
   
       class Program
       {
           static void Main(string[] args)
           {
               int? x = 3;
               int y = 3;
               bool check = false;
               if (x == y)
               {
                   check = true;
                   Console.WriteLine(check.ToString());
                   Console.ReadLine();
               }
    
           }
       }
   
   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 .
   
       class Program
       {
           static void Main(string[] args)
           {
               int? x = null;
               int y = 4;
               int? result;
               result = x ?? y;
               Console.WriteLine(result.ToString());
               Console.ReadLine();
           }
       }
   
   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 first variable is null then that value will be assigned else the value of 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 :-
   
       class Program
       {
           static void Main(string[] args)
           {
               int? x = 4;
               int y = x;
               Console.WriteLine(y.ToString());
               Console.ReadLine();
           }
       }
   
   This code snippet will generate 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.
   
      class Program
       {
           static void Main(string[] args)
           {
               int? x = 4;
               int y = x ?? 0;
               Console.WriteLine(y.ToString());
               Console.ReadLine();
           }
       }
   
   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".