View source for Null-Conditional-Operator

= Null Conditional Operator (?.) =
__TOC__

The Null Conditional Operator (?.) is a powerful feature introduced in C# 6.0 that provides a concise and safe way to access members or elements of an object without worrying about null reference exceptions. It simplifies null checking and enhances code readability.

== Overview ==

The Null Conditional Operator (?.) allows you to safely access members of an object without explicitly checking for null. It short-circuits the evaluation if the left operand is null, returning null immediately instead of throwing a NullReferenceException.

The purpose of the Null Conditional Operator is to streamline null checking and improve code robustness by providing a concise syntax for handling null references. It reduces boilerplate code and makes code more readable by eliminating the need for explicit null checks before accessing members of an object.

== Example ==

Consider the following example:

<pre>
class Person
{
    public string Name { get; set; }
}

Person person = null;

// Without Null Conditional Operator
string name = person != null ? person.Name : null;

// With Null Conditional Operator
string name = person?.Name;
</pre>

In this example, the Null Conditional Operator (`?.`) eliminates the need for explicit null checking before accessing the `Name` property of the `person` object.

== Benefits ==

* '''Conciseness:''' Provides a concise syntax for null checking, reducing the verbosity of code.
* '''Readability:''' Enhances code readability by making null checking more explicit and intuitive.
* '''Safety:''' Helps prevent NullReferenceException by short-circuiting evaluation if the object is null.

== Use Cases ==

* '''Chained Member Access:''' Allows safe navigation through multiple levels of object properties or nested objects.
* '''Method Invocation:''' Safely calls methods on objects that may be null, avoiding method invocation on null references.

== Best Practices ==

* '''Use Sparingly:''' While the Null Conditional Operator is useful, it should be used judiciously to maintain code clarity.
* '''Avoid Deep Nesting:''' Avoid deep nesting of Null Conditional Operators to maintain code readability.
* '''Use when saving lines''': Employ the Null Conditional Operator when it helps condense code and streamline readability, particularly in scenarios where succinctness enhances clarity without sacrificing understanding.

== Syntax ==
<pre>
var result = obj?.Member;
</pre>

Where:
* `obj` is the object whose member is being accessed.
* `Member` is the member of the object that you want to access.

=== Indexers === 

You can use the Null Conditional Operator with indexers to safely access elements of an array or collection without worrying about null references.
<pre>
int? length = myArray?.Length;
</pre>
If `myArray` is null, `length` will be null; otherwise, it will contain the length of the array.

=== Method Invocation  ===

You can use the Null Conditional Operator to invoke methods on objects that may be null. If the object is null, the method call is skipped, and the expression evaluates to null.
<pre>
int? count = myList?.Count();
</pre>
If `myList` is null, `count` will be null; otherwise, it will contain the count of elements in the list.

=== Nullable Value Types  ===

If the member being accessed returns a value type, the result of the expression will be nullable. This allows you to handle cases where the member itself might be null, or if the value type is nullable.
<pre>
int? age = person?.Age;
</pre>
If `person` is null or if the `Age` property of `person` is null, `age` will be null; otherwise, it will contain the age value.

=== Null Coalescing Operator (??) with Null Conditional Operator  ===

You can combine the Null Conditional Operator with the Null Coalescing Operator to provide a default value if the member accessed is null.
<pre>
int age = person?.Age ?? 0;
</pre>
If `person` is null or if the `Age` property of `person` is null, `age` will be assigned the default value of 0; otherwise, it will contain the age value.

=== Method Chaining  ===

You can chain multiple Null Conditional Operators together to access nested members or invoke methods on nested objects.
<pre>
string country = person?.Address?.Country;
</pre>
If `person` or `person.Address` is null, `country` will be null; otherwise, it will contain the country value from the address.

=== Conditional Access on Arrays  ===

You can use the Null Conditional Operator to safely access elements of multidimensional arrays or arrays of objects that may be null.
<pre>
int? value = myArray?[0]?.Length;
</pre>
If `myArray` is null or the first element is null, `value` will be null; otherwise, it will contain the length of the first element of the array.

[[File:Null conditional operator questionmark meme.jpg|center|alt=Meme from ToyStory stating Question Marks Everywhere]]