Semantic Differences and Performance Analysis Between "x is null" and "x == null" in C# 7

Introduction

In C# 7.0, the constant pattern matching feature was introduced, allowing developers to use syntax like if (x is null) to check if a variable is null. This has sparked widespread discussion about its differences from the traditional if (x == null) approach. This article systematically analyzes the similarities and differences between these two methods from semantic, compiler behavior, and performance perspectives.

Evolution of Compiler Behavior

According to updates in the Roslyn compiler, when a type does not overload the equality operator, is null and == null now exhibit the same optimized behavior in the latest versions. IL code analysis shows that both now use the efficient ceq instruction for direct comparison, eliminating the additional overhead from earlier versions where is null invoked the System.Object::Equals method. For example, for simple reference type checks:

public void M1(object x) {
    if (x is null) return;
}

public void M2(object x) {
    if (x == null) return;
}

The IL code for both is now simplified to:

IL_0000: ldarg.1
IL_0001: ldnull
IL_0002: ceq
IL_0004: ret

This optimization ensures that in scenarios without overloading, both writing styles are completely equivalent in performance.

Impact of Operator Overloading

When a type overloads the == operator, the semantic differences between is null and == null become significant. is null always performs direct reference comparison, while == null invokes the overloaded operator method. Consider the following example:

public class Foo {
    public static bool operator ==(Foo foo1, Foo foo2) {
        if (object.Equals(foo2, null)) throw new Exception("oops");
        return object.Equals(foo1, foo2);
    }
    // Other necessary members omitted
}

void Test() {
    Foo foo = null;
    if (foo is null) Console.WriteLine("foo is null"); // Executes normally
    if (foo == null) Console.WriteLine("foo == null"); // Throws exception
}

Here, foo is null safely detects null via the ceq instruction, while foo == null triggers an exception in the overloaded operator. This difference means that is null can avoid executing user code that may contain erroneous logic or performance issues.

Extended Applications of Constant Patterns

The constant pattern of the is operator is not limited to null checks; it can also be used for type-aware comparisons with other constant values. For example:

public void Test(object o) {
    if (o is 1) Console.WriteLine("a");
    else Console.WriteLine("b");
}
// Calling Test(1) outputs "a"

Here, o is 1 considers the type information of the constant 1, whereas o == (object)1 might yield different results due to type conversion. This demonstrates the advantage of the is pattern in type matching.

Practical Recommendations

Based on the above analysis, developers can choose according to the following scenarios:

• When it is certain that the type does not overload the == operator and code consistency is desired, both can be used interchangeably.
• When it is necessary to avoid potential side effects of overloaded operators (e.g., exceptions, performance overhead), prefer is null.
• When comparing other constant values and type safety is required, use the is constant pattern.
• In maintaining legacy code, adhere to existing styles to reduce cognitive load.

In summary, is null offers more predictable reference comparison semantics, particularly performing more robustly in complex type systems with operator overloading.