C# NULLABLES ~ mkniit

C# NULLABLES

Definition 

Nullablle type is a data type containing a defined data type or a null value.
You should note here that here the variable datatype has been awarded and then only may be used.
The concept of a nullable type are not compatible with “var”.
I will explain this with the syntax in the next section.

Declaration

Any datatype can be declared nullable types with the help of the “?” operator.

An 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 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 object. 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 variable is .Net whick can be used effectively while dealing with Database.

Different Types of Operatios on this Nullable type and Expected Results

Now let us discuss with detail 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:

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 implicity convert type ‘int?’ to ‘int’. An explicit conversion exist (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();

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.

For example look at following code:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

    class tutorialsProgrammings

    {

        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.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

    class tutorialsProgrammings

    {

        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:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

    class tutorialsProgrammings

    {

        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 work around for this with the help of null coalescing operator.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

    class tutorialsProgrammings

    {

        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”.

I will be writing more about nullable types in my next article.