"is null" expression efficiency

[madelson]

#With the new ability to write x is null in C# 7, I anticipate questions on whether this is preferable/equivalent to x == null as we role out C# 7 at my workplace.

Looking at the generated IL code, it seems that x == null generally does a better job since x is null always calls Object.Equals(a, b). This seems especially costly for Nullable<T>, since in that case we get a boxing operation. Interestingly, the null pattern in switch statements does not seem to have this issue.

For the sake of simplicity, it would be nice if x is null had the exact same performance as x == null and
case null:, avoiding a (very minor) performance gotcha.

Version Used: C# 7 (via LinqPad)

Steps to Reproduce:

1. I wrote the following C# code and compiled in LinqPad with optimization on:

public class Program
{
	public static void Main(string[] args) { }

	public bool IsNullA(int? a)
	{
		switch (a)
		{
			case null: return true;
			default: return false;
		}
	}

	public bool IsNullB(int? a)
	{
		return a is null;
	}

	public bool IsNullC(object s)
	{
		switch (s)
		{
			case null: return true;
			default: return false;
		}
	}

	public bool IsNullD(object s)
	{
		return s is null;
	}
}

2. This produces the following IL:

Program.IsNullA:
IL_0000:  ldarg.1     
IL_0001:  stloc.0     
IL_0002:  ldloca.s    00 
IL_0004:  call        System.Nullable<System.Int32>.get_HasValue
IL_0009:  brfalse.s   IL_0015
IL_000B:  ldloca.s    00 
IL_000D:  call        System.Nullable<System.Int32>.GetValueOrDefault
IL_0012:  stloc.1     
IL_0013:  br.s        IL_0017
IL_0015:  ldc.i4.1    
IL_0016:  ret         
IL_0017:  ldc.i4.0    
IL_0018:  ret         

Program.IsNullB:
IL_0000:  ldloca.s    00 
IL_0002:  initobj     System.Nullable<System.Int32>
IL_0008:  ldloc.0     
IL_0009:  box         System.Nullable<System.Int32>
IL_000E:  ldarg.1     
IL_000F:  box         System.Nullable<System.Int32>
IL_0014:  call        System.Object.Equals
IL_0019:  ret         

Program.IsNullC:
IL_0000:  ldarg.1     
IL_0001:  stloc.0     
IL_0002:  ldloc.0     
IL_0003:  brtrue.s    IL_0007
IL_0005:  ldc.i4.1    
IL_0006:  ret         
IL_0007:  ldc.i4.0    
IL_0008:  ret         

Program.IsNullD:
IL_0000:  ldnull      
IL_0001:  ldarg.1     
IL_0002:  call        System.Object.Equals
IL_0007:  ret        

Expected Behavior:
IsNullA should use a HasValue call for the null check and IsNullD should use a branch instruction.

Actual Behavior:
IsNullA and IsNullD both use Object.Equals(a, b).

[alrz]

#13247

[sharwell]

@madelson Thank you for the comprehensive report with the descriptive IL blocks. I'm closing this as a duplicate, but know that it's still very much appreciated to now have this extra information available. 👍