Null Propagation Operator In C# 6.0

using System;
class Program
{
    static void Main()
    {
        string str = null; // Here we declare the string as null
        if (str.Length == 0) // By this line, the error will occur
        {
            Console.WriteLine(str); // Due to the exception, the compiler never goes to this line
        }
        Console.Read();
    }
}

using System;
class Program
{
    static void Main()
    {
        string str = "rizwan ali mansoori";
        if (str.Length != 0)
        {
            Console.WriteLine("Now we provide the value for the string, and it is not null");
            Console.WriteLine("so the output is " + str);
        }
        Console.Read();
    }
}

using System;
class Program
{
    static void Main()
    {
        try
        {
            string str = null; // Here we declare the string as null
            if (str.Length == 0) // By this line, the error will occur
            {
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Please provide some value for the string");
        }
        Console.Read();
    }
}

Output

This is the overall information about the Null Reference Exception, what is it, how it can exist, how to handle it in our code, and what the reasons are for it. The end user never wants to see the abnormal termination of his code. He always wants a specific message or warning when he gets errors, so it is necessary for every programmer to please check for the null value of every member that we use in our code.

Null Propagation Operator(?) in C# 6.0

As we said above, C# 6.0 introduced the null propagation operator for checking for null values in code. The null propagation operator is denoted by "?". The basic advantage of using the null propagation operator is to reduce the code we write to check the null condition in our code. Using this operator, we can have less code than the previous code. Using the null propagation operator, we can easily manage the null reference exception.

Before we write the code, something like this.

Console.WriteLine(a.age == null ? 10001 : a.age.no1);

But now we write it in a minimized way like this.

Console.WriteLine(a.age?.no1 ?? 10001);

Here I provide an example of the Null propagation operator.

Example

using System;
namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = new first
            {
                number = 1234
            };
            Console.WriteLine(a.age.no1);

            Console.Read();
        }
    }
    class first
    {
        public int number { get; set; }
        public second age { get; set; }
    }
    class second
    {
        public int no1 { get; set; }
        public int no2 { get; set; }
    }
}

It provides the null reference exception like the output.

Output

Now we handle this exception by the old method.

Code of the old method in C# 6.0

using System;
namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = new first
            {
                number = 1234
            };
            Console.WriteLine(a.age == null ? 10001 : a.age.no1); // old method
            Console.Read();
        }
    }
    class first
    {
        public int number { get; set; }
        public second age { get; set; }
    }
    class second
    {
        public int no1 { get; set; }
        public int no2 { get; set; }
    }
}

Output

Now finally, we remove this exception using the null propagation operator and reduce the code. If we do not specify null, then we check for null only by the "?" operator.

Code of new method in C# 6.0

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = new first
            {
                number = 1234
            };
            Console.WriteLine(a.age?.no1 ?? 10001); // new code

            Console.Read();
        }
    }
    class first
    {
        public int number { get; set; }
        public second age { get; set; }
    }
    class second
    {
        public int no1 { get; set; }
        public int no2 { get; set; }
    }
}

Output

Summary

C# 6.0 has many new features in it. One of them is the null propagation operator. It has the property that if we make a reference variable in our code and want to check its value for null or not null before invoking the object using the null propagation operator, we can check it and remove the null exception error. It also increases the reliability of code and reduces the lines of code. That makes the code cleaner and easier.