Please see my comment in the code below. How should I check for the parameter to be null
? It looks like null
is being casted to Foo
which essentially makes a recursive call the the ==
operator. Why does this happen?
public class Foo
{
public static bool operator ==(Foo f1, Foo f2)
{
if (f1 == null) //This throw a StackOverflowException
return f2 == null;
if (f2 == null)
return f1 == null;
else
return f1.Equals((object)f2);
}
public static bool operator !=(Foo f1, Foo f2)
{
return !(f1 == f2);
}
public override bool Equals(object obj)
{
Foo f = obj as Foo;
if (f == (Foo)null)
return false;
return false;
}
public override int GetHashCode()
{
return 0;
}
}
A StackOverflowException is thrown when the execution stack overflows because it contains too many nested method calls. using System; namespace temp { class Program { static void Main(string[] args) { Main(args); // Oops, this recursion won't stop. } } }
Remarks. StackOverflowException is thrown for execution stack overflow errors, typically in case of a very deep or unbounded recursion. So make sure your code doesn't have an infinite loop or infinite recursion. StackOverflowException uses the HRESULT COR_E_STACKOVERFLOW, which has the value 0x800703E9.
A stack overflow is a type of buffer overflow error that occurs when a computer program tries to use more memory space in the call stack than has been allocated to that stack.
One method to prevent stack overflow is to track the stack pointer with test and measurement methods. Use timer interrupts that periodically check the location of the stack pointer, record the largest value, and watch that it does not grow beyond that value.
Why does this happen?
Because the language rules say to.
You've provided an operator with this signature:
public static bool operator ==(Foo f1, Foo f2)
and then - wherever this happens to be in code - you've got this expression:
f1 == null
where f1
has a compile-time type of Foo
. Now null
is implicitly convertible to Foo
as well, so why wouldn't it use your operator? And if you've got the first line of your operator unconditionally calling itself, you should expect a stack overflow...
In order for this not to happen, you'd need one of the two changes to the language:
==
meant when it's used within a declaration for ==
. Ick.==
expression with one operand being null
always meant the reference comparison.Neither is particularly nice, IMO. Avoiding it is simple though, avoids redundancy, and adds an optimization:
public static bool operator ==(Foo f1, Foo f2)
{
if (object.ReferenceEquals(f1, f2))
{
return true;
}
if (object.ReferenceEquals(f1, null) ||
object.ReferenceEquals(f2, null))
{
return false;
}
return f1.Equals(f2);
}
However, you then need to fix your Equals
method, because that then ends up calling back to your ==
, leading to another stack overflow. You've never actually ended up saying how you want equality to be determined...
I would normally have something like this:
// Where possible, define equality on sealed types.
// It gets messier otherwise...
public sealed class Foo : IEquatable<Foo>
{
public static bool operator ==(Foo f1, Foo f2)
{
if (object.ReferenceEquals(f1, f2))
{
return true;
}
if (object.ReferenceEquals(f1, null) ||
object.ReferenceEquals(f2, null))
{
return false;
}
// Perform actual equality check here
}
public override bool Equals(object other)
{
return this == (other as Foo);
}
public bool Equals(Foo other)
{
return this == other;
}
public static bool operator !=(Foo f1, Foo f2)
{
return !(f1 == f2);
}
public override int GetHashCode()
{
// Compute hash code here
}
}
Note that this allows you to only bother with nullity checks in one place. In order to avoid redundantly comparing f1
for null when it's been called via an instance method of Equals
to start with, you could delegate from ==
to Equals
after checking for nullity of f1
, but I'd probably stick to this instead.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With