Возможный дубликат:
Как проверить нули в перегрузке оператора '== без бесконечной рекурсии?
Вероятно, это легкий ответ на этот вопрос... но, похоже, он ускользает от меня. Вот упрощенный пример:
public class Person
{
public string SocialSecurityNumber;
public string FirstName;
public string LastName;
}
Скажем, что для этого конкретного приложения справедливо сказать, что если числа социального обеспечения совпадают, и оба имени совпадают, то мы имеем в виду одного и того же "человека".
public override bool Equals(object Obj)
{
Person other = (Person)Obj;
return (this.SocialSecurityNumber == other.SocialSecurityNumber &&
this.FirstName == other.FirstName &&
this.LastName == other.LastName);
}
Чтобы все было согласовано, мы переопределяем и операторы == и!= для разработчиков в команде, которые не используют метод .Equals.
public static bool operator !=(Person person1, Person person2)
{
return ! person1.Equals(person2);
}
public static bool operator ==(Person person1, Person person2)
{
return person1.Equals(person2);
}
Прекрасный и денди, верно?
Однако, что происходит, когда объект Person null?
Вы не можете написать:
if (person == null)
{
//fail!
}
Так как это приведет к переопределению оператора ==, и код не будет выполнен:
person.Equals()
вызов метода, поскольку вы не можете вызвать метод для нулевого экземпляра.
С другой стороны, вы не можете явно проверить это условие внутри переопределения ==, так как это вызовет бесконечную рекурсию (и переполнение стека [dot com])
public static bool operator ==(Person person1, Person person2)
{
if (person1 == null)
{
//any code here never gets executed! We first die a slow painful death.
}
return person1.Equals(person2);
}
Итак, как вы переопределяете операторы == и!= для равенства значений и по-прежнему учитываете нулевые объекты?
Я надеюсь, что ответ не будет болезненно простым.: -)
Используйте object.ReferenceEquals(person1, null) вместо оператора ==:
public static bool operator ==(Person person1, Person person2)
{
if (object.ReferenceEquals(person1, null))
{
return object.ReferenceEquals(person2, null);
}
return person1.Equals(person2);
}
вы всегда можете переопределить и поместить
(Object)(person1)==null
Я бы предположил, что это сработает, но не уверен.
Я всегда делал это так (для операторов == и! =), и я повторно использую этот код для каждого создаваемого объекта:
public static bool operator ==(Person lhs, Person rhs)
{
// If left hand side is null...
if (System.Object.ReferenceEquals(lhs, null))
{
// ...and right hand side is null...
if (System.Object.ReferenceEquals(rhs, null))
{
//...both are null and are Equal.
return true;
}
// ...right hand side is not null, therefore not Equal.
return false;
}
// Return true if the fields match:
return lhs.Equals(rhs);
}
"! =", то происходит следующим образом:
public static bool operator !=(Person lhs, Person rhs)
{
return !(lhs == rhs);
}
Изменить
Я изменил операционную функцию == в соответствии с предлагаемой Microsoft версией здесь.
Вставьте экземпляр Person в object:
public static bool operator ==(Person person1, Person person2)
{
if ((object)person1 == (object)person2) return true;
if ((object)person1 == null) return false;
if ((object)person2 == null) return false;
return person1.Equals(person2);
}
Перегрузка этих операторов последовательно довольно сложная. Мой ответ на соответствующий вопрос может служить шаблоном.
В принципе, вам сначала нужно выполнить ссылку (object.ReferenceEquals), чтобы проверить, есть ли объект null. Затем вы вызываете Equals.
Перенесите Person в объект и затем выполните сравнение:
object o1 = (object)person1;
object o2 = (object)person2;
if(o1==o2) //compare instances.
return true;
if (o1 == null || o2 == null) //compare to null.
return false;
//continue with Person logic.
Последняя (гипотетическая) процедура приведена ниже. Он очень похож на первый принятый ответ @cdhowie.
public static bool operator ==(Person person1, Person person2)
{
if (Person.ReferenceEquals(person1, person2)) return true;
if (Person.ReferenceEquals(person1, null)) return false; //*
return person1.Equals(person2);
}
Спасибо за отличные ответы!
//* - .Equals() выполняет нулевую проверку на person2
cdhowie находится на деньгах с использованием ReferenceEquals, но стоит заметить, что вы все равно можете получить исключение, если кто-то передает null непосредственно на Equals. Кроме того, если вы собираетесь переопределить Equals, почти всегда стоит реализовать IEquatable<T>, поэтому я бы вместо этого имел.
public class Person : IEquatable<Person>
{
/* more stuff elided */
public bool Equals(Person other)
{
return !ReferenceEquals(other, null) &&
SocialSecurityNumber == other.SocialSecurityNumber &&
FirstName == other.FirstName &&
LastName == other.LastName;
}
public override bool Equals(object obj)
{
return Equals(obj as Person);
}
public static bool operator !=(Person person1, Person person2)
{
return !(person1 == person2);
}
public static bool operator ==(Person person1, Person person2)
{
return ReferenceEquals(person1, person2)
|| (!ReferenceEquals(person1, null) && person1.Equals(person2));
}
}
И, конечно, вы никогда не должны переопределять Equals и не переопределять GetHashCode()
public override int GetHashCode()
{
//I'm going to assume that different
//people with the same SocialSecurityNumber are extremely rare,
//as optimise by hashing on that alone. If this isn't the case, change this
return SocialSecurityNumber.GetHashCode();
}
Также стоит отметить, что идентичность влечет равенство (то есть для любого действительного понятия "равенства" что-то всегда равно себе). Поскольку тесты на равенство могут быть дорогими и происходят в циклах, и поскольку сравнение чего-то с самим собой, как правило, довольно распространено в реальном коде (например, если объекты передаются в нескольких местах), его можно добавить как ярлык:
public bool Equals(Person other)
{
return !ReferenceEquals(other, null) &&
ReferenceEquals(this, other) ||
(
SocialSecurityNumber == other.SocialSecurityNumber &&
FirstName == other.FirstName &&
LastName == other.LastName
);
}
Насколько значительная часть сокращения на ReferenceEquals(this, other) может значительно варьироваться в зависимости от характера класса, но стоит ли это делать или нет, это то, что нужно всегда учитывать, поэтому я включаю здесь технику.
Легче любого из этих подходов было бы просто использовать
public static bool operator ==(Person person1, Person person2)
{
EqualityComparer<Person>.Default.Equals(person1, person2)
}
Это имеет ту же нулевую семантику равенства, что и подходы, которые предлагают все остальные, но это проблема структуры, чтобы выяснить детали:)