The null conditional operator (`?.)` is colloquially referred to as the “Elvis operator” because of its resemblance to a pair of dark eyes under a large quiff of hair. The null conditional is a form of a member access operator (`the .`).

Here’s a simplified explanation for the null conditional operator:

The expression

A?.Bevaluates toBif the left operand (A) is non-null; otherwise, it evaluates tonull.

Many more details fully define the behavior:

- The type of the expression
`A?.B`is the type of`B`, in cases where`B`is a reference type. If`B`is a value type, the expression`A?.B`is the nullable type that wraps the underlying value type represented by`B`. - The specification for the feature mandates that
`A`be evaluated no more than once. - The null conditional operator short-circuits, which means that you can chain multiple
`?.`operators, knowing that the first`null`encountered prevents the remaining (rightmost) components of the expression from being evaluated.

Let’s look at some examples to explain those behaviors. Consider this simplified `Car` class:

public class Car { public string Model { get; set; } public int Speed { get; set; } public int FuelType { get; set; } }

Assume that `c` represents a car. Consider these two statements:

var model = c?.Model; var speed = c?.Speed;

The variable model is a string. The value of model depends on the value of `c`. If `c` is null, model is null. If `c` is not null, model is the value of `c.Model`. Note that `c.Model `may be null even when `c` is not.

The variable speed is an `int?` (which is another way of specifying a `Nullable<int>`). As with `speed`, the value of speed depends on the value of `c`. If `c` is null, speed is an `int?` with no value. If `c` is non-null, speed is the wrapped value of `c.Speed`.

That’s the basics. The power of this feature comes from all the scenarios where this feature enables cleaner code.