等于与另一个可空类型上的可空类型进行比较

Question

I have two objects(of the same type) which contains a prop myprop of type byte? . The properties are set to null . When I perform objectA.myprop.Equals(objectB.myprop) I get 'true' as a result although the MSDN code sample states that "Equals applied to any null object returns false."

I'm guessing C# uses a seperate overload for nullable type comparisons. I would like to know how C# internally treats objects versus nullable types in this case.

Answer 1

When you call it like that, it will use Nullable<T>.Equals(object) which shows the expected behaviour in the documentation:

(Return value is true if...)

The HasValue property is false, and the other parameter is null . That is, two null values are equal by definition.

Likewise for equality via == , section 7.3.7 of the C# 4 spec (lifted operators) states:

For the equality operators == [and] != a lifted form of an operator exists if the operand types are both non-nullable value types and if the result type is bool. The lifted form is constructed by adding a single ? modifier to each operand type. The lifted operator considers two null values equal , and a null value unequal to any non-null value. If both operands are non-null, the lifted operator unwraps the operands and applies the underlying operator to produce the bool result.

(Emphasis mine.)

EDIT: Now I actually disagree with the accepted answer here, where it says it's not a general rule. It is a general rule, in terms of the implementation of object.Equals :

The following statements must be true for all implementations of the Equals method. In the list, x, y, and z represent object references that are not null.

[...]

• x.Equals(null) returns false.

So while it is a general rule, it doesn't apply in this specific case - because the value here isn't an object reference - it's a value type value . It's still somewhat surprising, unless you basically accept that Nullable<T> is a bit of a special case - it has specific C# compiler support and it has CLR support in terms of boxing and unboxing.

Answer 2

I have edited this for clarity.

You misunderstood that quote. To give the full context:

string s = null;
string t = String.Empty; // Logically the same as ""

// Equals applied to any null object returns false.
bool b = (t.Equals(s));

This is saying that a reference to a string object does not equate to a null reference. You took that quote out of context, and interpreted it as a general rule, which it is not. However this is referring to references NOT nullable types.

When you are dealing with nullable primitive types:

The actual rule is

An equality comparison of two nullable types that are both null evaluates to true.

http://msdn.microsoft.com/en-us/library/2cf62fcy.aspx

Answer 3

Nullable type is a struct and a struct never get a null value, so when a nullable type equals with null, this is means that this variable not really null rather a implicit cast occurred and that variable cast to a value type(nullable) with property Value=null . So:

int? a=null;//(a) get a memory space with value property = null
a.GetHashcode();//if (a) really is null must throw a exception but not throw 

Answer 4

I would claim that Nullable comparison X==Y behave exactly as should intuitively be expected, but I sense a possible misunderstanding here regarding X.Equals(Y) , which behaves as if it is a static method call.

object A, B;
MyStruct? X, Y;

The quote "Equals applied to any null object returns false." is true for the non-static method A.Equals(B) , and should typically hold for any sensible overrides of it.

However, the only reason this is so, is because A.Equals is a non-static method belonging to A , meaning A can never be null . Attempting A.Equals(B) with A = null would indeed throw a NullReferenceException .

The reason this has to be so is that the instance referred to by A might be of a more specific type than the declared variable A , and this more specific type might in turn override the A.Equals method. In other words, if A is null, then the runtime have no idea which implementation of A.Equals to use, and must therefore throw an Exception .

However static methods can't be overridden, meaning A can be null because the method to run is known already at compile-time. (This is why calling static methods is marginally faster than calling their non-static counterparts, and also why the compiler may decide to inline some static calls, but I am digressing.)

So, for any static implementations both operands can be null . Also, null should always be considered the same as null , and different from any other value. (If an implementation of Equals deviates from this common assumption, then that will typically be considered a bug.)

Examples of static Equals methods:

A==B;
A!=B;
MyClass.Equals(A, B);
object.Equals(A, B);
ReferenceEquals(A, B);

In this regard Nullable behave the same way as objects. The only difference being that X.Equals(Y) supports either X or Y or both to be null without throwing an Exception. So it is more correct to say that it behaves like the static equality methods mentioned above, which is typically more desirable.

But how is it possible for X.Equals(Y) to behave like a static method? This is because Nullable is a struct. Structs in C# does not support inheritance, so there is no difference between the type of the variable and the type of the instance. Which is why the runtime is never in doubt of which method Equals refers to. And so no Exception is needed. Any value supported by the struct can therefore be supported by the method for both operands, and null is therefore just another value.

Now, in addition to this there is some built-in special support for syntactical sugar and optimizations for Nullable types, but the behavior remains, as far as I know, as I described above.