C# 6.0 provides a new way of checking null values compared to its traditional ways.

In earlier versions, to avoid a nullpointerexception, we need to do null checking before invocation of a function.

C# 6.0 provides a null-conditional operator (?) that can be used to avoid writing redundant code every time a null check must be done.

However, developers need to be cautious about its usage and return a value assigned to variables. The null-conditional operator short-circuits the actual operation and performs a null check. The result of the short circuiting is NULL if the operand itself is null. Siince null values cannot be assigned to value types, using a null-conditional operator as shown below would throw a compile time error:

  1. string inputString="Mario";
  2. int length=inputString?.Length
In the list of advancements of the null checking, the Null-conditional operator can also be used to check on indexers, in other words check a collection to determine if it is null before retrieving an item from a collection.
  1. T? item = collection?[index];
The null-conditional index form of the operator ? causes indexing into a collection to occur only if the collection isn't null. That is programmatically equivalent to:
  1. T? item = (collection != null) ? collection[index] : null.
Note that the null-conditional operator can only retrieve items. It won’t work to assign an item. Also pay attention to the implicit ambiguity when using the ? […] operator on a reference type. Because reference types can be null, a null result from the ? […] operator should not be mistaken with whether the collection was null or the element itself was, in fact, null.

Another common pattern where the null-conditional operator could be used is in combination with the coalesce operator. Instead of checking for null on docList before invoking Length, you can retrieve an item count as follows:
  1. List<string> docList = GetListOfDocuments("c:/temp/");
  2. return docList?.Count ?? 0;
In this case, any empty collection (no documents) and a null collection are both normalized to return the same count.

Another highly awaited feature in the list is to check for null before invoking a delegate. Thanks to the Microsoft team because this problem has been persistent since C# 1.0 .

Traditional approach:
  1. public class Delegate_Example
  2. {
  3. public event EventHandler<float> OnPriceChanged;
  4. private int _price;
  5. public int Price
  6. {
  7. get
  8. {
  9. return _price;
  10. }
  11. set
  12. {
  13. EventHandler<float> localOnchanged = OnPriceChanged;
  14. if (localOnchanged!=null)
  15. {
  16. _price = value;
  17. localOnchanged(this, value);
  18. }
  20. }
  21. }
  22. }
New approach:
  1. public class Delegate_Example
  2. {
  3. public event EventHandler<float> OnPriceChanged;
  4. private int _price;
  6. public int Price
  7. {
  8. get
  9. {
  10. return _price;
  11. }
  13. set
  14. {
  15. OnPriceChanged?.Invoke(this, value);
  16. }
  17. }
  18. }
Short summary
  1. Short-circuit additional invocations in the call chain if the operand is null.

  2. Return null if the operand is null.

  3. Support invocation of dele in a thread safe manner.

  4. Return a nullable type (System.Nullable<T>) if the target member returns a value type.

  5. Available as both a member operator (?.) and an index operator (?[…]).