Почему (object) 0 == (object) 0 отличается от ((object) 0) .Equals ((object) 0)?

Почему следующие выражения разные?

[1]  (object)0 == (object)0 //false
[2]  ((object)0).Equals((object)0) // true

На самом деле, я могу полностью понять [1], потому что, вероятно, среда выполнения .NET будет boxиспользовать целое число и вместо этого начнет сравнивать ссылки. Но почему [2] отличается?

Причина, по которой вызовы ведут себя по-разному, заключается в том, что они привязаны к очень разным методам.

==Дело будет связываться со статическим оператором ссылки равенства. Созданы 2 независимых intзначения в штучной упаковке, поэтому они не являются одной и той же ссылкой.

Во втором случае вы привязываетесь к методу экземпляра Object.Equals. Это виртуальный метод, который будет фильтровать Int32.Equalsи проверять на наличие упакованного целого числа. Оба целых значения равны 0, следовательно, они равны

Когда вы приводите значение int 0(или любой другой тип значения) к object, значение помещается в рамку . Каждое приведение к objectсоздает другой блок (то есть другой экземпляр объекта). ==Оператор для objectпреформ типа ссылки сравнения, поэтому он возвращает ложь , так как левая сторона и правая не тот же экземпляр.

С другой стороны, когда вы используете Equals, который является виртуальным методом, он использует реализацию фактического упакованного типа, т. Int32.EqualsЕ. Который возвращает истину, поскольку оба объекта имеют одинаковое значение.

==Оператор, будучи статическим, не является виртуальным. Он будет запускать точный код, который objectопределяет класс (`object является типом времени компиляции операндов), который будет выполнять сравнение ссылок, независимо от типа среды выполнения любого объекта.

EqualsМетод представляет собой виртуальный метод экземпляра. Он будет запускать код, определенный в фактическом типе времени выполнения (первого) объекта, а не код в objectклассе. В этом случае объект является объектом int, поэтому он будет выполнять сравнение значений, поскольку это то, что intтип определяет для своего Equalsметода.

Equals()Метод является виртуальным.
Таким образом, он всегда вызывает конкретную реализацию, даже когда вызывается object. intпереопределяет Equals()сравнение по значению, поэтому вы получаете сравнение значений.

== Использование: Object.ReferenceEquals

Object.Equals сравнивает значение.

object.ReferenceEqualsМетод сравнивает ссылку. Когда вы выделяете объект, вы получаете ссылку, содержащую значение, указывающее его расположение в памяти, в дополнение к данным объекта в куче памяти.

object.EqualsМетод сравнивает содержимое объектов. Сначала он проверяет, равны ли ссылки, как и object.ReferenceEquals. Но затем он вызывает производные методы Equals для дальнейшей проверки равенства. Посмотри это:

   System.Object a = new System.Object();
System.Object b = a;
System.Object.ReferenceEquals(a, b);  //returns true

Оператор C # использует токен ==для представления двух разных операторов: статически перегружаемого оператора сравнения и неперегружаемого оператора сравнения ссылок. Когда он встречает ==токен, он сначала проверяет, существует ли какая-либо перегрузка проверки равенства, которая применима к типам операндов. Если это так, он вызовет эту перегрузку. В противном случае он проверит, применимы ли типы к оператору сравнения ссылок. Если это так, он будет использовать этот оператор. Если ни один из операторов не применим к типам операндов, компиляция завершится ошибкой.

Код (Object)0не просто повышает Int32до Object:, Int32как и все типы значений, фактически представляет два типа, один из которых описывает значения и места хранения (например, буквальный ноль), но не является производным от чего-либо, а один из которых описывает кучи объекты и производные от Object; поскольку только последний тип может быть приведен к восходящему преобразованию Object, компилятор должен создать новый объект кучи этого последнего типа. Каждый вызов (Object)0создает новый объект кучи, поэтому два операнда to ==являются разными объектами, каждый из которых независимо инкапсулирует Int32значение 0.

Класс Objectне имеет каких-либо используемых перегрузок, определенных для оператора равенства. Следовательно, компилятор не сможет использовать перегруженный оператор проверки на равенство и вернется к использованию проверки на равенство ссылок. Поскольку два операнда ==относятся к различным объектам, он будет сообщать false. Второе сравнение завершается успешно, поскольку оно запрашивает у одного экземпляра объекта кучи Int32, равен ли он другому. Поскольку этот экземпляр знает, что значит быть равным другому отдельному экземпляру, он может ответить true.

Обе проверки разные. Первый проверяет идентичность , второй - равенство . В общем, два термина идентичны, если они относятся к одному и тому же объекту. Это означает, что они равны. Два члена равны, если их значения совпадают.

С точки зрения программирования идентичность обычно искажается ссылочным равенством. Если указатели на оба термина равны (!), То объект, на который они указывают, точно такой же. Однако, если указатели разные, значение объектов, на которые они указывают, может быть одинаковым. В C # идентичность можно проверить с помощью статического Object.ReferenceEqualsчлена, в то время как равенство проверяется с помощью нестатического Object.Equalsчлена. Так как вы бросаете два целых числа к объектам (который называется «бокс», кстати), то operatior ==из objectпреформ первый чек, который по умолчанию отображается в Object.ReferenceEqualsи проверяет идентичность. Если вы явно вызываете нестатический Equalsчлен, динамическая отправка приводит к вызову Int32.Equals, который проверяет равенство.

Обе концепции похожи, но не одинаковы. Сначала они могут показаться запутанными, но небольшая разница очень важна! Представьте себе двух человек, а именно «Алису» и «Боба». Они оба живут в желтом доме. Исходя из предположения, что Алиса и Боб живут в районе, где дома различаются только цветом, они оба могут жить в разных желтых домах. Если вы сравните оба дома, вы поймете, что они абсолютно одинаковые, потому что оба желтые! Однако они не живут в одном доме, и поэтому их дома равны , но не идентичны . Идентичность подразумевает, что они живут в одном доме.

Примечание : некоторые языки определяют ===оператора для проверки идентичности.