Null-Coalescing Operator in C#

In C#, ?? operator is known as Null-coalescing operator. It will return the value of its left-hand operand if it is not null. If it is null, then it will evaluate the right-hand operand and returns its result. Or if the left-hand operand evaluates to non-null, then it does not evaluate its right-hand operand. Syntax:

p ?? q

Here, p is the left and q is the right operand of ?? operator. The value of p can be nullable type, but the value of q must be non-nullable type. If the value of p is null, then it returns the value of q. Otherwise, it will return the value of p. Important Points:

• The ?? operator is used to check null values and you can also assign a default value to a variable whose value is null(or nullable type).
• You are not allowed to overload ?? operator.
• It is right-associative.
• In ?? operator, you can use throw expression as a right-hand operand of ?? operator which makes your code more concise.
• You are allowed to use ?? operator with value types and reference types. Example: CSharp

  // C# program to illustrate how to use 
  // ?? operator with value types and
  // reference types
  using System;
   
  namespace example {
   
  class Program {
      static void Main(string[] args)
      {
   
          // Reference types
          string item_1 = null;
          string item_2 = "GeeksforGeeks";
          string item_3 = "GFG";
   
          string item_4 = item_1 ?? item_2;
          item_3 = item_4 ?? item_2;
   
          Console.WriteLine("Value of item_4 is: {0} \n"+
                "Value of item_3 is: {1}", item_4, item_3);
   
          // Value types
          int ? item_5 = null;
   
          Program obj = new Program();
   
          // Using ?? operator assigns
          // the value of a value type
          // and also you are allowed 
          // to use method with ?? operator
          int ? item_6 = item_5 ?? obj.Add(10, 30);
          Console.WriteLine("Value of item_6 is: {0}", item_6);
      }
   
      // Method
      public int Add(int a, int b)
      {
          int result = a + b;
          return result;
      }
  }
  }
  

  Output:

  Value of item_4 is: GeeksforGeeks 
  Value of item_3 is: GeeksforGeeks
  Value of item_6 is: 40
  

• With the help of ?? operator you can prevent InvalidOperationException. Example: CSharp

  // C# program to illustrate how ?? 
  // operator prevent the 
  // InvalidOperationException
  using System;
   
  namespace example {
   
  class GFG {
      
      // Main Method
      static void Main(string[] args)
      {
          // Creating items of nullable types
          int ? item_1 = null;
   
           /*
           Here if you use this commented part,
           then this statement will give you an
           InvalidOperationException. So to 
           overcome this problem we use ?? operator 
           int? item_2 = item_1.Value;
           */
   
          // With the help of ?? operator we 
          // assign a default value to the item_2
          // And the value of item_1 is null.
          int ? item_2 = item_1 ?? 100;
          Console.WriteLine("Value of item_1 is: {0}", item_1);
          Console.WriteLine("Value of item_2 is: {0}", item_2);
      }
  }
  }
  

  Output:

  Value of item_1 is: 
  Value of item_2 is: 100
  

• With the help of ?? operator you can remove many redundant "if-else" conditions and make your code compact and readable. Example: CSharp

  // C# program to illustrate how ?? 
  // operator replaces if-else statements
  using System;
   
  namespace example {
   
  class GFG {
      
      // Main Method
      static void Main(string[] args)
      {
          // Creating items of nullable types
          int ? item_1 = null;
   
          int ? item_2;
   
          if (item_1.HasValue) {
              item_2 = item_1;
          }
          else {
              item_2 = 200;
          }
          Console.WriteLine("Value of item_1 is: {0}", item_1);
          Console.WriteLine("Value of item_2 is: {0}", item_2);
      }
  }
  }
  

  Output:

  Value of item_1 is: 
  Value of item_2 is: 200
  

  CSharp

  // C# program to illustrate how ??
  // operator replaces if-else statements
  using System;
   
  namespace example {
   
  class GFG {
      
      // Main Method
      static void Main(string[] args)
      {
          // Creating items of nullable types
          int ? item_1 = null;
   
          // Using ?? operator
          int ? item_2 = item_1 ?? 200;
          Console.WriteLine("Value of item_1 is: {0}", item_1);
          Console.WriteLine("Value of item_2 is: {0}", item_2);
      }
  }
  }
  

  Output:

  Value of item_1 is: 
  Value of item_2 is: 200
  

• ?? operator can be nested. It will make your code more readable and also reduce multiple if-else conditions. Example: CSharp

  // C# program to illustrate how 
  // we use nested ?? operator
  using System;
   
  namespace example {
   
  class GFG {
      
      // Main Method
      static void Main(string[] args)
      {
          // Creating items of nullable types
          int ? item_1 = null;
          int ? item_2 = null;
          int ? item_3 = 500;
   
          // Nested ?? operator
          int ? item_4 = item_1 ?? item_2 ?? item_3;
          
          Console.WriteLine("Value of item_4 is: {0} ", item_4);
      }
  }
  }
  

  Output:

  Value of item_4 is: 500