Is pattern matching preferred over reference or value equality?

Question

I see a lot of examples on how to use pattern matching in C#7. It all looks good. However, I have a question, which I do not seem to be able to find an answer for.

Say you have the following expression:

if (a is null)

My question is: Is it preferred to use pattern matching instead of reference or value equality with C#7?

So instead of writing:

if (a == null)

or:

if (a.Equals(null))

or:

if (object.Equals(a, null))

I suspect the a is null generates something like the last expression. But would it in general be preferred to switch to pattern matching?

Correct me if I am wrong and this is a primarily opinion based question, but I could not seem to find a definitive answer that backed this up.

Answer 1

Consider the following four code snippets:

// 1
var x = "";
var y = x is null;

// 2
var x = "";
var y = x.Equals(null);

// 3
var x = "";
var y = object.Equals(x, null);

// 4
var x = "";
var y = x == null;

The IL for these, respectively, is:

// 1
IL_0001: ldstr ""
IL_0006: stloc.0
IL_0007: ldnull
IL_0008: ldloc.0
IL_0009: call bool [mscorlib]System.Object::Equals(object, object)
IL_000e: stloc.1

// 2
IL_0001: ldstr ""
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: ldnull
IL_0009: call bool [mscorlib]System.Object::Equals(object, object)
IL_000e: stloc.1

// 3 
IL_0001: ldstr ""
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: ldnull
IL_0009: call bool [mscorlib]System.Object::Equals(object, object)
IL_000e: stloc.1

// 4
IL_0001: ldstr ""
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: ldnull
IL_0009: ceq
IL_000b: stloc.1

As you can see, the first three result in near identical code. The == version uses ceq rather than .Equals() .

I'm guessing ceq is faster, and thus x == null is the fastest way of testing for null . Beyond that, it becomes a matter of preferred style.

Answer 2

No matter if optimization is enabled, IL:

r = a is null;
IL_0004: ceq

r = a.Equals(null);
IL_0009: callvirt instance bool [mscorlib]System.Object::Equals(object)

r = Equals(a, null);
IL_0011: call bool [mscorlib]System.Object::Equals(object, object)

r = a == null;
IL_0019: ceq

r = a == default;
IL_001e: ceq

r = a == default(object);
IL_0023: ceq

r = ReferenceEquals(a, null);
IL_0028: ceq

I removed the repetitive noise for each expression:

IL_0002: ldloc.0
IL_0003: ldnull
      // ...
IL_0006: stloc.1

a.Equals(null) will throw an exception if a = null , so it is far from preferred.

Most probably a == null is used (short form, desired effect).

It should be noted that the operator == and method object.Equals can be overridden.

In the case that certain class have bad impacts with (significant performance degradation or worse - throws exception on) a == null then you can use for sure ReferenceEquals(a, null) .

ReferenceEquals always performs only the comparison of two objects and also uses ceq .
Lack of call for ReferenceEquals means for me something à la AggressiveInlining (IL size: 5).

Did you can use is ? Of course you can.

But it look strange for me. You do not check the a type, rather you ask if a points to null.