equals c что делает
Equals() и как работает сравнение типов в C#
Сравнение типов через Equals() и == в Reference Type
Как работает Equals() в C#
В классе System.Object есть все несколько методов, один из них ReferenceEquals
Стоить отметить, что == и RefefenceEquals работает идентично, сравнивая ссылки на объекты в heap’е, а значит при выполнении данного кода
На консоль будет выведено:
По сути за этим для стандартной реализации object.Equals скрывается вызов ReferenceEquals под капотом.
При этом определение того, какой метод Equals вызвать определяется на динамическом типе левого аргумента.
Например, перепишем наш старый пример, где переопределим метод Equals :
На экране мы увидим:
У типа Object есть еще один статический метод static bool Equals(Object objA, Object objB)
Его исходный код выглядит следующим образом:
Этот является оберткой виртуального метода Equals, но перед его вызовом, делает проверку равенства ссылок путем == и проверку на null каждого из объектов проверки.
Сравнение Value типов через Equals
Давайте разберемся как этот метод сравнивает value типы:
Совет:
Сравнение с помощью вспомогательных классов и интерфейсов
IEqualityComparer
IComparable
IStructuralEquatable
Пример реализации этого интерфейса можно подсмотреть в System.Array :
Алгоритм реализации такого интерфейса в System.Array прост:
Правила реализации метода Equals и оператора равенства (==)
При реализации метода Equals и оператора равенства (==) следует руководствоваться следующим:
Type. Equals Метод
Определение
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Определяет, совпадает ли базовый системный тип текущего объекта Type с базовым системным типом указанного объекта Object или Type.
Перегрузки
Позволяет определить, совпадает ли базовый системный тип текущего объекта Type с базовым системным типом указанного объекта Type.
Определяет, совпадает ли базовый системный тип текущего объекта Type с базовым системным типом указанного объекта Object.
Equals(Type)
Позволяет определить, совпадает ли базовый системный тип текущего объекта Type с базовым системным типом указанного объекта Type.
Параметры
Объект, базовый системный тип которого сравнивается с базовым системным типом текущего типа Type.
Возвращаемое значение
Реализации
Примеры
В следующем примере используется Equals для сравнения двух типов.
См. также раздел
Применяется к
Equals(Object)
Определяет, совпадает ли базовый системный тип текущего объекта Type с базовым системным типом указанного объекта Object.
Параметры
Объект, базовый системный тип которого сравнивается с базовым системным типом текущего типа Type. Для успешного сравнения необходимо, чтобы параметр o можно было привести к объекту типа Type или преобразовать в объект такого типа.
Возвращаемое значение
o невозможно привести к объекту или преобразовать в объект Type.
Реализации
Примеры
В следующем примере используется Equals(Object) для сравнения различных Type экземпляров объектов с различными Object экземплярами.
В примере следует обратить внимание на две вещи:
String. Equals Метод
Определение
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Определяет, равны ли значения двух объектов String.
Перегрузки
Определяет, равны ли значения этой строки и указанного объекта String. Параметр определяет язык и региональные параметры, учет регистра и правила сортировки, используемые при сравнении.
Определяет, совпадают ли значения двух указанных объектов String.
Определяет, совпадают ли значения двух указанных объектов String. Параметр определяет язык и региональные параметры, учет регистра и правила сортировки, используемые при сравнении.
Определяет, равны ли значения этого экземпляра и указанного объекта, который также должен быть объектом String.
Определяет, равны ли значения этого экземпляра и указанного объекта String.
Equals(String, StringComparison)
Определяет, равны ли значения этой строки и указанного объекта String. Параметр определяет язык и региональные параметры, учет регистра и правила сортировки, используемые при сравнении.
Параметры
Строка для сравнения с данным экземпляром.
Одно из значений перечисления, задающее способ сравнения строк.
Возвращаемое значение
Исключения
comparisonType не является значением StringComparison.
Примеры
В следующем примере создается массив строк, состоящий из прописной буквы I, строчной буквы i и точки с «ı». Затем он вызывает Equals(String, StringComparison) метод, чтобы сравнить их с помощью каждого возможного StringComparison значения перечисления.
В следующем примере сравниваются четыре набора слов с помощью каждого члена StringComparison перечисления. В сравнениях используются соглашения для языков и региональных параметров «Английский (США)» и «Sami» (Upper Швеция). Обратите внимание, что строки «енциклопæдиа» и «енциклопаедиа» считаются эквивалентными в культуре en-US, но не в культуре (Северный Швеция).
Комментарии
comparisonType Параметр указывает, должно ли сравнение использовать текущий или инвариантный язык и региональные параметры, учитывать или игнорировать регистр двух сравниваемых строк либо использовать правила сортировки по словам или порядковому номеру.
Object. Equals Метод
Определение
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Определяет, равны ли два экземпляра объекта.
Перегрузки
Определяет, равен ли указанный объект текущему объекту.
Определяет, считаются ли равными указанные экземпляры объектов.
Equals(Object)
Определяет, равен ли указанный объект текущему объекту.
Параметры
Объект, который требуется сравнить с текущим объектом.
Возвращаемое значение
Примеры
некоторые языки, такие как C# и Visual Basic, поддерживают перегрузку операторов. Если тип перегружает оператор равенства, он также должен переопределять Equals(Object) метод, чтобы обеспечить ту же функциональность. Обычно это достигается путем написания Equals(Object) метода с точки зрения перегруженного оператора равенства, как показано в следующем примере.
Поскольку Complex является типом значения, он не может быть производным от. поэтому Equals(Object) методу переопределения метода не требуется вызывать GetType для определения точного типа времени выполнения каждого объекта, но вместо этого можно использовать is оператор в C# или TypeOf оператор в Visual Basic для проверки типа obj параметра.
Комментарии
Тип сравнения текущего экземпляра и obj параметра зависит от того, является ли текущий экземпляр ссылочным типом или типом значения.
Если текущий экземпляр является типом значения, Equals(Object) метод проверяет равенство значений. Равенство значений означает следующее:
Два объекта имеют один и тот же тип. Как показано в следующем примере, Byte объект со значением 12 не равен Int32 объекту со значением 12, поскольку два объекта имеют разные типы времени выполнения.
примечания для среда выполнения Windows
Windows классы среды выполнения, написанные на языке C# или Visual Basic, могут переопределять Equals(Object) перегрузку метода.
Примечания для вызывающих объектов
Производные классы часто переопределяют Object.Equals(Object) метод для реализации равенства значений. Кроме того, типы часто предоставляют дополнительный строго типизированную перегрузку для Equals метода, обычно реализуя IEquatable интерфейс. При вызове Equals метода для проверки на равенство следует знать, переопределяются ли текущий экземпляр Object.Equals и понимаете, как Equals разрешается определенный вызов метода. В противном случае вы можете выполнить проверку на равенство, отличное от предполагаемого, и метод может вернуть непредвиденное значение.
Примечания для наследников
В следующем примере показано, как переопределить Object.Equals(Object) метод для проверки на равенство значений. Он переопределяет Equals метод для Person класса. Если он Person принял реализацию равенства базового класса, два Person объекта будут равны, только если они ссылались на один объект. Однако в этом случае два Person объекта равны, если они имеют одинаковое значение для Person.Id Свойства.
Следующие инструкции должны быть истинными для всех реализаций Equals(Object) метода. В списке,, x y и z представляют ссылки на объекты, которые не равны null.
Типы, переопределяющие, Equals(Object) также должны переопределяться GetHashCode ; в противном случае хэш-таблицы могут работать неправильно.
Рекомендации по ссылочным типам
Следующие рекомендации применяются для переопределения Equals(Object) ссылочного типа.
Рассмотрите возможность переопределения, Equals Если семантика типа основана на том, что тип представляет некоторые значения.
Рекомендации по типам значений
Ниже приведены рекомендации по переопределению Equals(Object) для типа значения.
Если вы переопределяете Equals и язык разработки поддерживает перегрузку операторов, необходимо перегрузить оператор равенства.
Equals и GetHashCode в C# это сложно
Работать в C# с Equals и GetHashCode по многим причинам непросто, даже несмотря на наличие разного рода инструментов. Особенно по сравнению с тем, как это могло бы быть в нормально спроектированном ЯП, к которым, к большому сожалению, C#, в данном контексте, не относится. Если вам интересно, что это за проблемы, для чего этот метод вообще нужен, почему этот механизм реализован именно так, а не как-то иначе, как можно было сделать лучше, то добро пожаловать под кат.
Если есть некоторый инструмент и этим инструментом сложно пользоваться, то обычно на это есть как объективные, так и необъективные причины. Порой мир устроен довольно сложно, и под на первый взгляд «простым» инструментом может скрываться сколь угодно сложная система. Поэтому не всегда удается реализовать инструмент так, чтобы им было легко пользоваться на регулярной основе. Особенно если это делается в первый раз. Но зачастую это не значит, что это невозможно в принципе. И обычно, делая работу над ошибками, инструмент можно довести до ума, разумеется, при наличии желания.
Другой проблемой может быть то, что не всегда очевидно, что данным инструментом трудно пользоваться или то, что его сразу можно было сделать лучше. Никто не обратил внимание, что при использовании могут возникнуть проблемы. Или создатели инструмента не подозревали, как пользователи будут с ним работать, или даже что пользователи вообще будут работать с ним. И самое главное: большинство производителей не слушают своих пользователей и, как следствие, не подозревают, что у последних есть сложности с их инструментом (а части производителей и вообще глубоко плевать на все и всех). Это вообще довольно острая проблема, которая относится не только к нашей сегодняшней теме, но и в целом к современному ПО, т.к. зачастую им невозможно пользоваться вообще. Порой нельзя сделать что-то, даже строго следуя инструкции (не говоря уже о чем-то более сложном и при условии, что инструкция вообще есть). Но не будем о грустном.
Не всегда одного желания достаточно, чтобы что-то исправить. Например, если разрабатываемый инструмент используется для создания других инструментов, то исправить ранее допущенную при проектировании ошибку (проблему, неудобство и т.д.) может быть невозможно из-за необходимости поддержки обратной совместимости. Поэтому к проектированию подобных инструментов необходимо подходить намного более тщательно, ибо назад пути может и не быть, и исправить не получится. Но одно дело, когда вы первопроходец, и, так сказать, идете по тонкому льду, и совсем другое, когда перед вами уже реализованы десятки подобных инструментов, и все, что вам нужно, — это сделать еще более удобный инструмент. И довольно странно допускать подобные ошибки в таких случаях.
Идентичность и эквивалентность
Если начать разбираться со всеми возможными вариантами механизмов для реализации проверок на идентичность и эквивалентность в C#, то невольно можно задаться вопросом: почему все так сложно? Дело в том, что нельзя однозначно ответить (а, соответственно, и реализовать в общем виде) на вопрос, равны ли два объекта или нет, так как под равенством может подразумеваться все, что угодно, и многое зависит от контекста использования. В одном случае два объекта могут считаться равными, а в другом эти же самые объекты уже не равны. Таким образом, частично сложность механизмов сравнения на равенство в C# обусловлена сложностью самой концепции сравнения.
Можно выделить два основных вида эквивалентности: значимое равенство (Value Equality) и ссылочное равенство (Referential equality). В первом случае подразумевается эквивалентность в некотором смысле, которая может зависеть как от контекста использования, так и от самих объектов. Во втором случае два объекта являются эквивалентными только в случае, если они ссылаются на один и тот же объект. По умолчанию значимые типы используют первый вид эквивалентности. А ссылочные типы — второй. Например: