When overloading the ==
operator in C#, avoid infinite recursion when dealing with null values
There is a common problem when handling null values when overloading the ==
operator in C#. Consider the following code snippet:
<code class="language-csharp">Foo foo1 = null; Foo foo2 = new Foo(); Assert.IsFalse(foo1 == foo2); public static bool operator ==(Foo foo1, Foo foo2) { if (foo1 == null) return foo2 == null; // 潜在的无限递归 return foo1.Equals(foo2); }</code>
In this case, the ==
overload uses the ==
operator itself to check for null values. This can lead to infinite recursion because if foo1
is empty, foo2 == null
will also evaluate to empty, causing the ==
method to be called infinitely.
To avoid this problem, the ==
overload should use ReferenceEquals
instead of ==
to check for null values. ReferenceEquals
does not perform recursive calls, so it can safely determine whether one or two objects are null without causing infinite recursion. The corrected code is as follows:
<code class="language-csharp">Foo foo1 = null; Foo foo2 = new Foo(); Assert.IsFalse(foo1 == foo2); public static bool operator ==(Foo foo1, Foo foo2) { if (object.ReferenceEquals(foo1, null)) return object.ReferenceEquals(foo2, null); return foo1.Equals(foo2); }</code>
By modifying the null check to use ReferenceEquals
, the ==
overload handles null values efficiently without triggering infinite recursion. It correctly compares the null values of Equals
and foo1
before moving on to the foo2
comparison. This approach ensures that the operator's behavior is always consistent and reliable, even in the presence of null values.
This revised explanation clarifies the problem and solution more concisely. The image remains in its original format and location.
The above is the detailed content of How to Avoid Infinite Recursion When Overloading the '==' Operator in C# with Null Checks?. For more information, please follow other related articles on the PHP Chinese website!