C＃JIT编译器是否优化空检查？

Question

There are many articles online that list the optimizations made by the C# JIT before executing a piece of code. For example this post on MSDN talks about:

Constant folding, Constant and copy propagation, Common subexpression elimination, Code motion of loop invariants, Dead store and dead code elimination, Register allocation, Method inlining, Loop unrolling (small loops with small bodies).

My question is: does the JIT compiler deals also with useless null-checks? I can't find any source treating this question.

In the same article I read:

since the C# language specification ensures that any call on a null object reference throws a NullReferenceException, every call site must ensure the instance is not null. This is done by dereferencing the instance reference; if it is null it will generate a fault that is turned into this exception.

So, suppose I write a piece of code like this:

if (person != null)
{
    Console.WriteLine(person.Name);
}

The person.Name calls again a second null-check that is cleary useless, and the compiler could remove it. Or not?

I read that in Java this is already done (some sources between many here , here and here ).

If C# does it too, do you know some source or documentation that talks about that?

If instead C# doesn't do it, do you know why? Is there an intrinsic difficulty in implementing such a feature for a .NET environment that the Java JIT does not encounter?

Answer 1

Null check optimization done by the compiler (Roslyn, not Jitter) in several cases , when its completly save to do that.

For example when you use ? (Elvis operator).

IL_0006: stloc.0              // Pop a value from stack into local variable 0
IL_0007: ldloc.0              // Load local variable 0 onto stack
IL_0008: brtrue.s IL_000c     // Branch to target if value is non-zero (true), short form
IL_000a: br.s IL_0013         // Branch to target, short form
IL_000c: ldloc.0              // Load local variable 0 onto stack
IL_000d: call instance void Foo::Bar() // Call method indicated on the stack with arguments

Another example is code like this:

new Bar().Foo();

The compiler generates for this call instruction and not callvirt (which means, no null check on this )

In other cases, you can't be sure that this not going to be null.

Anyway, null check is really really fast.