blocks|key|181065|text|调用行为不同的原因是它们绑定到非常不同的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181066|==用例将绑定到静态引用相等运算符。创建了2个独立的盒装int值，因此它们不是相同的引用。|offset|length|style|CODE|181067|在第二种情况下，绑定到实例方法Object.Equals。这是一个虚方法，它将向下过滤到Int32.Equals，并检查装箱的整数。两个整数值都是0，因此它们是相等的|181068|entityMap^0|0|0|2|S|3|0|F|D|18|C|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|K|$]]

The reason the calls behave different is they bind to very different methods. 

The <code>==</code> case will bind to the static reference equality operator. There are 2 independent boxed <code>int</code> values created hence they are not the same reference.

In the second case you bind to the instance method <code>Object.Equals</code>. This is a virtual method which will filter down to <code>Int32.Equals</code> and this checks for a boxed integer. Both integer values are 0 hence they are equal

blocks|key|4687196|text|==操作符是静态的，不是虚拟的。它将运行object类定义的完全相同的代码(`object是操作数的编译时类型)，该代码将执行引用比较，而不考虑任何对象的运行时类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4687197|Equals方法是一个虚拟实例方法。它将运行(第一个)对象的实际运行时类型中定义的代码，而不是object类中的代码。在本例中，对象是一个int，因此它将执行值比较，因为这是int类型为其Equals方法定义的值。|4687198|entityMap^0|0|2|K|6|0|0|6|1B|6|1X|3|2F|3|2M|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|I|$]]

The <code>==</code> operator, being static, is not virtual. It will run the exact code that the <code>object</code> class defines (`object being the compile time type of the operands), which will do a reference comparison, regardless of the runtime type of either object.

The <code>Equals</code> method is a virtual instance method. It will be running the code defined in the actual run-time type of the (first) object, not the code in the <code>object</code> class. In this case, the object is an <code>int</code>, so it will perform a value comparison, as that is what the <code>int</code> type defines for its <code>Equals</code> method.

blocks|key|4687170|text|Equals()方法是虚拟的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4687171|因此，即使调用站点被强制转换为object，它也总是调用具体的实现。int覆盖Equals()以按值进行比较，因此您可以进行值比较。|4687172|entityMap^0|0|8|0|F|6|Y|3|13|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

The <code>Equals()</code> method is virtual. 
Therefore, it always calls the concrete implementation, even when the callsite is casted to <code>object</code>.
<code>int</code> overrides <code>Equals()</code> to compare by value, so you get value comparison.

blocks|key|4687239|text|==使用：Object.ReferenceEquals|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4687240|Object.Equals对该值进行比较。|4687241|object.ReferenceEquals方法比较引用。分配对象时，除了对象在内存堆上的数据外，还会收到一个包含指示其内存位置的值的引用。|4687242|object.Equals方法比较对象的内容。它首先检查引用是否相等，object.ReferenceEquals也是如此。但随后它会调用派生的Equals方法来进一步测试相等性。请看以下内容：|4687243|+++System.Object+a+=+new+System.Object();
System.Object+b+=+a;
System.Object.ReferenceEquals(a,+b);++//returns+true|code-block|syntax|javascript|4687244|entityMap|0|LINK|mutability|MUTABLE|url|http://www.dotnetperls.com/object-referenceequals|1|http://www.dotnetperls.com/object-equals^0|0|2|5|M|0|0|D|0|0|M|0|M|0|0|0|D|0|D|1|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]]|E|$]]|$1|J|3|K|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|L|3|M|5|N|7|1K|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

<code>==</code> Use: <code>Object.ReferenceEquals</code>

<code>Object.Equals</code> compares the value.

The <a href="http://www.dotnetperls.com/object-referenceequals"><code>object.ReferenceEquals</code></a> method compares references. When you allocate an object, you receive a reference containing a value indicating its memory location in addition to the object's data on the memory heap.

The <a href="http://www.dotnetperls.com/object-equals"><code>object.Equals</code></a> method compares the contents of objects. It first checks whether the references are equal, as does object.ReferenceEquals. But then it calls into derived Equals methods to test equality further.
See this:

<pre><code> System.Object a = new System.Object();
System.Object b = a;
System.Object.ReferenceEquals(a, b); //returns true
</code></pre>

blocks|key|4687219|text|C#运算符使用令牌==来表示两个不同的运算符:可静态重载的比较运算符和不可重载的引用比较运算符。当它遇到==标记时，它首先检查是否存在适用于操作数类型的相等测试重载。如果是，它将调用该重载。否则，它将检查类型是否适用于引用比较运算符。如果是，它将使用该运算符。如果两个运算符都不适用于操作数类型，则编译将失败。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4687220|代码(Object)0不仅仅是将Int32向上转换为Object：与所有值类型一样，Int32实际上表示两种类型，一种描述值和存储位置(如文字零)，但不从任何地方派生，另一种描述堆对象并派生自Object；因为只有后一种类型可以向上转换为Object，所以编译器必须创建该类型的新堆对象。每次调用(Object)0都会创建一个新的堆对象，因此==的两个操作数是不同的对象，每个对象都独立地封装Int32值0。|4687221|类Object没有为等于运算符定义的任何可用重载。因此，编译器将无法使用重载的相等测试运算符，而将退回到使用引用相等测试。因为==的两个操作数引用不同的对象，所以它将报告false。第二次比较成功是因为它询问Int32的一个堆对象实例是否与另一个相等。因为该实例知道等于另一个不同的实例意味着什么，所以它可以回答true。|4687222|entityMap^0|9|2|1G|2|0|2|9|G|5|Q|6|16|5|2O|6|3B|6|44|9|4R|2|5G|5|0|1|6|1R|2|2D|5|2W|5|4C|4|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|K|$]]

The C# operator uses the token <code>==</code> to represent two different operators: a statically- overloadable comparison operator and a non-overloadable reference-comparison operator. When it encounters the <code>==</code> token, it first checks to see if there exists any equality-test overload which is applicable to the operand types. If so, it will invoke that overload. Otherwise, it will check whether the types are applicable to the reference-comparison operator. If so, it will use that operator. If neither operator is applicable to the operand types, compilation will fail.

The code <code>(Object)0</code> doesn't merely upcast an <code>Int32</code> to <code>Object</code>: <code>Int32</code>, like all value types, actually represents two types, one of which describes values and storage locations (such as the literal zero), but doesn't derive from anything, and one of which describes heap objects and derives from <code>Object</code>; because only the latter type may be upcast to <code>Object</code>, the compiler must create a new heap object of that latter type. Each invocation of <code>(Object)0</code> creates a new heap object, so the two operands to <code>==</code> are different objects, each of which, independently, encapsulates the <code>Int32</code> value 0.

The class <code>Object</code> does not have any usable overloads defined for the equals operator. Consequently, the compiler will not be able to use the overloaded equality-test operator, and will fall back to using the reference-equality test. Because the two operands to <code>==</code> refer to distinct objects, it will report <code>false</code>.
The second comparison succeeds because it asks one heap-object instance of <code>Int32</code> whether it's equal to the other. Because that instance knows what it means to be equal to another distinct instance, it can answer <code>true</code>.

Why are the following expressions different?

<pre><code>[1] (object)0 == (object)0 //false
[2] ((object)0).Equals((object)0) // true
</code></pre>

Actually, I can totally understand [1] because probably the .NET runtime will <code>box</code> the integer and start comparing the references instead. But why is [2] different?

Why is (object)0 == (object)0 different from ((object)0).Equals((object)0)?

编译器

为什么下面的表达式不同？[1]  (object)0 == (object)0 //false[2]  ((object)0).Equals((object)0) // true实际上，我可以完全理解1，因为.NET运行时可能会box整数并开始比较引用。但是为什么2是不同的呢？

问为什么(object)0 == (object)0和((object)0).Equals((object)0)不同？
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么(object)0 == (object)0和((object)0).Equals((object)0)不同？EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么(object)0 == (object)0和((object)0).Equals((object)0)不同？
EN