C # JIT compiler optimizes null-check?

Question

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

Constant bending, distribution of constants and copies, general subexpression exception, code movement of loop invariants, dead storage and dead code exception, register allocation, inlining method, Loop unrolling (small loops with small bodies).

My question is: is the JIT compiler dealing with useless zero checks? I can not find a source considering this issue.

In the same article, I read:

since the C # language specification ensures that any call to a null-value reference to an object throws a NullReferenceException, each call site must make sure that the instance is not null. This is done by dereferencing the reference to the instance; if it is zero, it will generate an error, which turned into this exception.

So, suppose I write a piece of code as follows:

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

person.Namecalls the second null check again, which is useless, and the compiler can delete it. Or not?

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

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

# , , ? .NET, JIT Java ?

Answer 1

Null , (Roslyn, Jitter) , .

, ? ( Elvis).

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

:

new Bar().Foo();

call, callvirt ( , this)

, this .

.