Существует ли полная ссылка на реализацию IEquatable?
Многие из моих вопросов здесь о SO касаются реализации IEquatable. Я обнаружил, что это крайне сложно реализовать правильно, потому что в наивной реализации много скрытых ошибок, и статьи, которые я нашел по этому поводу, довольно неполны. Я хочу найти или написать окончательную ссылку, которая должна включать:
- Как правильно реализовать IEquatable
- Как правильно переопределить Equals
- Как правильно переопределить GetHashCode
- Как правильно реализовать метод ToString
- Как правильно реализовать оператор ==
- Как реализовать оператор!= Правильно
Такая полная ссылка уже существует?
PS: даже ссылка на MSDN мне кажется ущербной
5 ответов
Внедрение IEquatable<T> для типа значения
Внедрение IEquatable<T> для типа значения немного отличается, чем для ссылочного типа. Давайте предположим, что у нас есть архетип Implement-Your-Own-Value-Type, структура сложных чисел.
public struct Complex
{
public double RealPart { get; set; }
public double ImaginaryPart { get; set; }
}
Нашим первым шагом будет внедрение IEquatable<T> и переопределить Object.Equals а также Object.GetHashCode:
public bool Equals(Complex other)
{
// Complex is a value type, thus we don't have to check for null
// if (other == null) return false;
return (this.RealPart == other.RealPart)
&& (this.ImaginaryPart == other.ImaginaryPart);
}
public override bool Equals(object other)
{
// other could be a reference type, the is operator will return false if null
if (other is Complex)
return this.Equals((Complex)other);
else
return false;
}
public override int GetHashCode()
{
return this.RealPart.GetHashCode() ^ this.ImaginaryPart.GetHashCode();
}
С очень небольшим усилием у нас есть правильная реализация, исключая операторов. Добавление операторов также является тривиальным процессом:
public static bool operator ==(Complex term1, Complex term2)
{
return term1.Equals(term2);
}
public static bool operator !=(Complex term1, Complex term2)
{
return !term1.Equals(term2);
}
Проницательный читатель заметит, что мы, вероятно, должны реализовать IEquatable<double> поскольку Complex числа могут быть взаимозаменяемыми с базовым типом значения.
public bool Equals(double otherReal)
{
return (this.RealPart == otherReal) && (this.ImaginaryPart == 0.0);
}
public override bool Equals(object other)
{
// other could be a reference type, thus we check for null
if (other == null) return base.Equals(other);
if (other is Complex)
{
return this.Equals((Complex)other);
}
else if (other is double)
{
return this.Equals((double)other);
}
else
{
return false;
}
}
Нам нужно четыре оператора, если мы добавим IEquatable<double>потому что вы можете иметь Complex == double или же double == Complex (и то же самое для operator !=):
public static bool operator ==(Complex term1, double term2)
{
return term1.Equals(term2);
}
public static bool operator ==(double term1, Complex term2)
{
return term2.Equals(term1);
}
public static bool operator !=(Complex term1, double term2)
{
return !term1.Equals(term2);
}
public static bool operator !=(double term1, Complex term2)
{
return !term2.Equals(term1);
}
Так что у вас есть, с минимальными усилиями у нас есть правильная и полезная реализация IEquatable<T> для типа значения:
public struct Complex : IEquatable<Complex>, IEquatable<double>
{
}
Я считаю, что получить что-то столь же простое, как проверка объектов на правильность, немного сложно с дизайном.NET.
Для структуры
1) Реализация IEquatable<T>, Это заметно улучшает производительность.
2) Так как у вас есть свой собственный Equals теперь переопределить GetHashCode и соответствовать различным переопределениям проверки на равенство object.Equals также.
3) Перегрузка == а также != операторы не должны быть религиозными, так как компилятор предупредит, если вы непреднамеренно приравниваете структуру к другой с == или же !=, но это хорошо, чтобы быть в соответствии с Equals методы.
public struct Entity : IEquatable<Entity>
{
public bool Equals(Entity other)
{
throw new NotImplementedException("Your equality check here...");
}
public override bool Equals(object obj)
{
if (obj == null || !(obj is Entity))
return false;
return Equals((Entity)obj);
}
public static bool operator ==(Entity e1, Entity e2)
{
return e1.Equals(e2);
}
public static bool operator !=(Entity e1, Entity e2)
{
return !(e1 == e2);
}
public override int GetHashCode()
{
throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
}
}
Для класса
От MS:
Большинство ссылочных типов не должны перегружать оператор равенства, даже если они переопределяют Equals.
Мне == ощущается как ценностное равенство, больше похоже на синтаксический сахар для Equals метод. Пишу a == b гораздо более интуитивно, чем писать a.Equals(b), Редко нам нужно проверять равенство ссылок. На абстрактных уровнях, имеющих дело с логическими представлениями физических объектов, это не то, что нам нужно проверять. Я думаю, что разные семантики для == а также Equals на самом деле может быть запутанным. Я считаю, что это должно было быть == для ценностного равенства и Equals для справки (или лучше как IsSameAs) равенство на первом месте. Я хотел бы не принимать всерьез рекомендации по РС, не только потому, что это не естественно для меня, но и потому, что перегрузка == не причиняет большого вреда Это не похоже на переопределение неуниверсального Equals или же GetHashCode который может откусить назад, потому что фреймворк не использует == где угодно, но только если мы сами это используем. Единственное реальное преимущество, которое я получаю, не перегружая == а также != будет согласованность с дизайном всей структуры, над которой я не имею никакого контроля. И это действительно большая вещь, так что, к сожалению, я буду придерживаться этого.
С эталонной семантикой (изменяемые объекты)
1) Переопределить Equals а также GetHashCode,
2) Реализация IEquatable<T> не обязательно, но будет хорошо, если у вас есть.
public class Entity : IEquatable<Entity>
{
public bool Equals(Entity other)
{
if (ReferenceEquals(this, other))
return true;
if (ReferenceEquals(null, other))
return false;
//if your below implementation will involve objects of derived classes, then do a
//GetType == other.GetType comparison
throw new NotImplementedException("Your equality check here...");
}
public override bool Equals(object obj)
{
return Equals(obj as Entity);
}
public override int GetHashCode()
{
throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
}
}
С семантикой значения (неизменяемые объекты)
Это сложная часть. Может легко запутаться, если не позаботиться..
1) Переопределить Equals а также GetHashCode,
2) перегрузка == а также != соответствовать Equals, Убедитесь, что это работает для нулей.
2) Реализация IEquatable<T> не обязательно, но будет хорошо, если у вас есть.
public class Entity : IEquatable<Entity>
{
public bool Equals(Entity other)
{
if (ReferenceEquals(this, other))
return true;
if (ReferenceEquals(null, other))
return false;
//if your below implementation will involve objects of derived classes, then do a
//GetType == other.GetType comparison
throw new NotImplementedException("Your equality check here...");
}
public override bool Equals(object obj)
{
return Equals(obj as Entity);
}
public static bool operator ==(Entity e1, Entity e2)
{
if (ReferenceEquals(e1, null))
return ReferenceEquals(e2, null);
return e1.Equals(e2);
}
public static bool operator !=(Entity e1, Entity e2)
{
return !(e1 == e2);
}
public override int GetHashCode()
{
throw new NotImplementedException("Your lightweight hashing algorithm, consistent with Equals method, here...");
}
}
Будьте особенно внимательны, чтобы увидеть, как это будет происходить, если ваш класс может быть унаследован, в таких случаях вам придется определить, может ли объект базового класса быть равным объекту производного класса. В идеале, если никакие объекты производного класса не используются для проверки на равенство, тогда экземпляр базового класса может быть равен экземпляру производного класса, и в таких случаях нет необходимости проверять Type равенство в общем Equals базового класса.
В общем, старайтесь не дублировать код. Я мог бы сделать общий абстрактный базовый класс (IEqualizable<T> или около того) в качестве шаблона, чтобы разрешить повторное использование проще, но, к сожалению, в C#, что мешает мне получить дополнительные классы.
Прочитав MSDN, я уверен, что лучший пример правильной реализации - на странице метода IEquatable.Equals. Мое единственное отклонение заключается в следующем:
public override bool Equals(Object obj)
{
if (obj == null) return base.Equals(obj);
if (! (obj is Person))
return false; // Instead of throw new InvalidOperationException
else
return Equals(obj as Person);
}
Для тех, кто интересуется отклонением, это происходит от страницы MSDN Object.Equals (Object):
Реализации Equals не должны создавать исключений.
Я нашел другую ссылку, это реализация.NET Anonymous Type. Для анонимного типа со свойствами типа int и double в качестве свойства я разобрал следующий код C#:
public class f__AnonymousType0
{
// Fields
public int A { get; }
public double B { get; }
// Methods
public override bool Equals(object value)
{
var type = value as f__AnonymousType0;
return (((type != null)
&& EqualityComparer<int>.Default.Equals(this.A, type.A))
&& EqualityComparer<double>.Default.Equals(this.B, type.B));
}
public override int GetHashCode()
{
int num = -1134271262;
num = (-1521134295 * num) + EqualityComparer<int>.Default.GetHashCode(this.A);
return ((-1521134295 * num) + EqualityComparer<double>.Default.GetHashCode(this.B);
}
public override string ToString()
{
StringBuilder builder = new StringBuilder();
builder.Append("{ A = ");
builder.Append(this.A);
builder.Append(", B = ");
builder.Append(this.B);
builder.Append(" }");
return builder.ToString();
}
}
Я должен только извлечь из этого класса
public abstract class DataClass : IEquatable<DataClass>
{
public override bool Equals(object obj)
{
var other = obj as DataClass;
return this.Equals(other);
}
public bool Equals(DataClass other)
{
return (!ReferenceEquals(null, other))
&& this.Execute((self2, other2) =>
other2.Execute((other3, self3) => self3.Equals(other3), self2)
, other);
}
public override int GetHashCode()
{
return this.Execute(obj => obj.GetHashCode());
}
public override string ToString()
{
return this.Execute(obj => obj.ToString());
}
private TOutput Execute<TOutput>(Func<object, TOutput> function)
{
return this.Execute((obj, other) => function(obj), new object());
}
protected abstract TOutput Execute<TParameter, TOutput>(
Func<object, TParameter, TOutput> function,
TParameter other);
}
А затем реализовать абстрактный метод, как это
public class Complex : DataClass
{
public double Real { get; set; }
public double Imaginary { get; set; }
protected override TOutput Execute<TParameter, TOutput>(
Func<object, TParameter, TOutput> function,
TParameter other)
{
return function(new
{
Real = this.Real,
Imaginary = this.Imaginary,
}, other);
}
}