Égalité et polymorphisme
Avec deux classes immuables Base et Derived (qui dérive de Base), je veux définir l'égalité afin que
l'égalité est toujours polymorphe - c'est-à-dire que
((Base)derived1).Equals((Base)derived2)appelleraDerived.Equalsles opérateurs
==et!=appellentEqualsplutôt queReferenceEquals(égalité de valeur)
Ce que j'ai fait:
class Base: IEquatable<Base> {
public readonly ImmutableType1 X;
readonly ImmutableType2 Y;
public Base(ImmutableType1 X, ImmutableType2 Y) {
this.X = X;
this.Y = Y;
}
public override bool Equals(object obj) {
if (object.ReferenceEquals(this, obj)) return true;
if (obj is null || obj.GetType()!=this.GetType()) return false;
return obj is Base o
&& X.Equals(o.X) && Y.Equals(o.Y);
}
public override int GetHashCode() => HashCode.Combine(X, Y);
// boilerplate
public bool Equals(Base o) => object.Equals(this, o);
public static bool operator ==(Base o1, Base o2) => object.Equals(o1, o2);
public static bool operator !=(Base o1, Base o2) => !object.Equals(o1, o2); }
Ici, tout se termine par Equals(object) qui est toujours polymorphe donc les deux cibles sont atteintes.
Je dérive alors comme ceci:
class Derived : Base, IEquatable<Derived> {
public readonly ImmutableType3 Z;
readonly ImmutableType4 K;
public Derived(ImmutableType1 X, ImmutableType2 Y, ImmutableType3 Z, ImmutableType4 K) : base(X, Y) {
this.Z = Z;
this.K = K;
}
public override bool Equals(object obj) {
if (object.ReferenceEquals(this, obj)) return true;
if (obj is null || obj.GetType()!=this.GetType()) return false;
return obj is Derived o
&& base.Equals(obj) /* ! */
&& Z.Equals(o.Z) && K.Equals(o.K);
}
public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), Z, K);
// boilerplate
public bool Equals(Derived o) => object.Equals(this, o);
}
Ce qui est fondamentalement le même, sauf pour un problème - lorsque j'appelle base.Equals J'appelle base.Equals(object) et non base.Equals(Derived) (ce qui provoquera une récursion sans fin).
Equals(C) fera également de la boxe/unboxing dans cette implémentation mais cela en vaut la peine pour moi.
Mes questions sont -
Est-ce d'abord correct? mon ( testing ) semble le suggérer, mais avec C # étant si difficile en égalité, je ne suis tout simplement plus sûr .. y a-t-il des cas où cela est faux?
et Deuxièmement - est-ce bien? existe-t-il de meilleurs moyens plus propres d'y parvenir?
Le code peut être simplifié en utilisant une combinaison d'une méthode d'extension et d'un code de chaudière. Cela enlève presque toute la douleur et laisse les classes concentrées sur la comparaison de leurs instances sans avoir à traiter tous les cas spéciaux Edge:
namespace System {
public static partial class ExtensionMethods {
public static bool Equals<T>(this T inst, object obj, Func<T, bool> thisEquals) where T : IEquatable<T> =>
object.ReferenceEquals(inst, obj) // same reference -> equal
|| !(obj is null) // this is not null but obj is -> not equal
&& obj.GetType() == inst.GetType() // obj is more derived than this -> not equal
&& obj is T o // obj cannot be cast to this type -> not equal
&& thisEquals(o);
}
}
Je peux maintenant faire:
class Base : IEquatable<Base> {
public SomeType1 X;
SomeType2 Y;
public Base(SomeType1 X, SomeType2 Y) => (this.X, this.Y) = (X, Y);
public bool ThisEquals(Base o) => (X, Y) == (o.X, o.Y);
// boilerplate
public override bool Equals(object obj) => this.Equals(obj, ThisEquals);
public bool Equals(Base o) => object.Equals(this, o);
public static bool operator ==(Base o1, Base o2) => object.Equals(o1, o2);
public static bool operator !=(Base o1, Base o2) => !object.Equals(o1, o2);
}
class Derived : Base, IEquatable<Derived> {
public SomeType3 Z;
SomeType4 K;
public Derived(SomeType1 X, SomeType2 Y, SomeType3 Z, SomeType4 K) : base(X, Y) => (this.Z, this.K) = (Z, K);
public bool ThisEquals(Derived o) => base.ThisEquals(o) && (Z, K) == (o.Z, o.K);
// boilerplate
public override bool Equals(object obj) => this.Equals(obj, ThisEquals);
public bool Equals(Derived o) => object.Equals(this, o);
}
C'est bien, pas de cast ou de vérifications nulles et tout le travail réel est clairement séparé dans ThisEquals.
( test )
Pour les classes immuables, il est possible d'optimiser davantage en mettant en cache le code de hachage et en l'utilisant dans Equals pour raccourcir l'égalité si les codes de hachage sont différents:
namespace System.Immutable {
public interface IImmutableEquatable<T> : IEquatable<T> { };
public static partial class ExtensionMethods {
public static bool ImmutableEquals<T>(this T inst, object obj, Func<T, bool> thisEquals) where T : IImmutableEquatable<T> =>
object.ReferenceEquals(inst, obj) // same reference -> equal
|| !(obj is null) // this is not null but obj is -> not equal
&& obj.GetType() == inst.GetType() // obj is more derived than this -> not equal
&& inst.GetHashCode() == obj.GetHashCode() // optimization, hash codes are different -> not equal
&& obj is T o // obj cannot be cast to this type -> not equal
&& thisEquals(o);
public static int GetHashCode<T>(this T inst, ref int? hashCache, Func<int> thisHashCode) where T : IImmutableEquatable<T> {
if (hashCache is null) hashCache = thisHashCode();
return hashCache.Value;
}
}
}
Je peux maintenant faire:
class Base : IImmutableEquatable<Base> {
public readonly SomeImmutableType1 X;
readonly SomeImmutableType2 Y;
public Base(SomeImmutableType1 X, SomeImmutableType2 Y) => (this.X, this.Y) = (X, Y);
public bool ThisEquals(Base o) => (X, Y) == (o.X, o.Y);
public int ThisHashCode() => (X, Y).GetHashCode();
// boilerplate
public override bool Equals(object obj) => this.ImmutableEquals(obj, ThisEquals);
public bool Equals(Base o) => object.Equals(this, o);
public static bool operator ==(Base o1, Base o2) => object.Equals(o1, o2);
public static bool operator !=(Base o1, Base o2) => !object.Equals(o1, o2);
protected int? hashCache;
public override int GetHashCode() => this.GetHashCode(ref hashCache, ThisHashCode);
}
class Derived : Base, IImmutableEquatable<Derived> {
public readonly SomeImmutableType3 Z;
readonly SomeImmutableType4 K;
public Derived(SomeImmutableType1 X, SomeImmutableType2 Y, SomeImmutableType3 Z, SomeImmutableType4 K) : base(X, Y) => (this.Z, this.K) = (Z, K);
public bool ThisEquals(Derived o) => base.ThisEquals(o) && (Z, K) == (o.Z, o.K);
public new int ThisHashCode() => (base.ThisHashCode(), Z, K).GetHashCode();
// boilerplate
public override bool Equals(object obj) => this.ImmutableEquals(obj, ThisEquals);
public bool Equals(Derived o) => object.Equals(this, o);
public override int GetHashCode() => this.GetHashCode(ref hashCache, ThisHashCode);
}
Ce qui n'est pas trop mal - il y a plus de complexité mais ce n'est que du passe-partout que je viens de couper et coller .. la logique est clairement séparée en ThisEquals et ThisHashCode
Eh bien, je suppose qu'il y a deux parties à votre problème:
- exécution égale au niveau imbriqué
- restreindre au même type
Est-ce que cela fonctionnerait? https://dotnetfiddle.net/eVLiMZ (J'ai dû utiliser une syntaxe plus ancienne car elle ne se compilait pas dans dotnetfiddle sinon)
using System;
public class Program
{
public class Base
{
public string Name { get; set; }
public string VarName { get; set; }
public override bool Equals(object o)
{
return object.ReferenceEquals(this, o)
|| o.GetType()==this.GetType() && ThisEquals(o);
}
protected virtual bool ThisEquals(object o)
{
Base b = o as Base;
return b != null
&& (Name == b.Name);
}
public override string ToString()
{
return string.Format("[{0}@{1} Name:{2}]", GetType(), VarName, Name);
}
public override int GetHashCode()
{
return Name.GetHashCode();
}
}
public class Derived : Base
{
public int Age { get; set; }
protected override bool ThisEquals(object o)
{
var d = o as Derived;
return base.ThisEquals(o)
&& d != null
&& (d.Age == Age);
}
public override string ToString()
{
return string.Format("[{0}@{1} Name:{2} Age:{3}]", GetType(), VarName, Name, Age);
}
public override int GetHashCode()
{
return base.GetHashCode() ^ Age.GetHashCode();
}
}
public static void Main()
{
var b1 = new Base { Name = "anna", VarName = "b1" };
var b2 = new Base { Name = "leo", VarName = "b2" };
var b3 = new Base { Name = "anna", VarName = "b3" };
var d1 = new Derived { Name = "anna", Age = 21, VarName = "d1" };
var d2 = new Derived { Name = "anna", Age = 12, VarName = "d2" };
var d3 = new Derived { Name = "anna", Age = 21, VarName = "d3" };
var all = new object [] { b1, b2, b3, d1, d2, d3 };
foreach(var a in all)
{
foreach(var b in all)
{
Console.WriteLine("{0}.Equals({1}) => {2}", a, b, a.Equals(b));
}
}
}
}
Cette méthode de comparaison utilisant Reflection qui, à part les méthodes d'extension, est plus simple. Il garde également les membres privés privés.
Toute la logique est dans la classe IImmutableExtensions. Il regarde simplement quels champs sont en lecture seule et les utilise pour la comparaison.
Vous n'avez pas besoin de méthodes dans les classes de base ou dérivées pour la comparaison d'objets. Appelez simplement la méthode d'extension ImmutableEquals lorsque vous remplacez ==, != Et Equals(). Même chose avec le hashcode.
public class Base : IEquatable<Base>, IImmutable
{
public readonly ImmutableType1 X;
readonly ImmutableType2 Y;
public Base(ImmutableType1 X, ImmutableType2 Y) => (this.X, this.Y) = (X, Y);
// boilerplate
public override bool Equals(object obj) => this.ImmutableEquals(obj);
public bool Equals(Base o) => this.ImmutableEquals(o);
public static bool operator ==(Base o1, Base o2) => o1.ImmutableEquals(o2);
public static bool operator !=(Base o1, Base o2) => !o1.ImmutableEquals(o2);
private int? _hashCache;
public override int GetHashCode() => this.ImmutableHash(ref _hashCache);
}
public class Derived : Base, IEquatable<Derived>, IImmutable
{
public readonly ImmutableType3 Z;
readonly ImmutableType4 K;
public Derived(ImmutableType1 X, ImmutableType2 Y, ImmutableType3 Z, ImmutableType4 K) : base(X, Y) => (this.Z, this.K) = (Z, K);
public bool Equals(Derived other) => this.ImmutableEquals(other);
}
Et la classe IImmutableExtensions:
public static class IImmutableExtensions
{
public static bool ImmutableEquals(this IImmutable o1, object o2)
{
if (ReferenceEquals(o1, o2)) return true;
if (o2 is null || o1.GetType() != o2.GetType() || o1.GetHashCode() != o2.GetHashCode()) return false;
foreach (var tProp in GetImmutableFields(o1))
{
var test = tProp.GetValue(o1)?.Equals(tProp.GetValue(o2));
if (test is null) continue;
if (!test.Value) return false;
}
return true;
}
public static int ImmutableHash(this IImmutable o, ref int? hashCache)
{
if (hashCache is null)
{
hashCache = 0;
foreach (var tProp in GetImmutableFields(o))
{
hashCache = HashCode.Combine(hashCache.Value, tProp.GetValue(o).GetHashCode());
}
}
return hashCache.Value;
}
private static IEnumerable<FieldInfo> GetImmutableFields(object o)
{
var t = o.GetType();
do
{
var fields = t.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).Where(field => field.IsInitOnly);
foreach(var field in fields)
{
yield return field;
}
}
while ((t = t.BaseType) != typeof(object));
}
}
Ancienne réponse: (je vais laisser cela pour référence)
Sur la base de ce que vous disiez à propos du transtypage en object, il m'est venu à l'esprit que les méthodes Equals(object) et Equals(Base) étaient trop ambiguës lors de leur appel à partir d'une classe dérivée.
Cela m'a dit que la logique devrait être déplacée des deux classes vers une méthode qui décrirait mieux nos intentions.
L'égalité restera polymorphe car ImmutableEquals dans la classe de base appellera le ValuesEqual substitué. C'est là que vous pouvez décider dans chaque classe dérivée comment comparer l'égalité.
Ceci est votre code refactorisé avec cet objectif.
Réponse révisée:
Il m'est venu à l'esprit que toute notre logique dans IsEqual() et GetHashCode() fonctionnerait si nous fournissions simplement un Tuple qui contenait les champs immuables que nous voulions comparer. Cela évite de dupliquer autant de code dans chaque classe.
C'est au développeur qui crée la classe dérivée de remplacer GetImmutableTuple(). Sans utiliser la réflexion (voir autre réponse), je pense que c'est le moindre de tous les maux.
public class Base : IEquatable<Base>, IImmutable
{
public readonly ImmutableType1 X;
readonly ImmutableType2 Y;
public Base(ImmutableType1 X, ImmutableType2 Y) =>
(this.X, this.Y) = (X, Y);
protected virtual IStructuralEquatable GetImmutableTuple() => (X, Y);
// boilerplate
public override bool Equals(object o) => IsEqual(o as Base);
public bool Equals(Base o) => IsEqual(o);
public static bool operator ==(Base o1, Base o2) => o1.IsEqual(o2);
public static bool operator !=(Base o1, Base o2) => !o1.IsEqual(o2);
public override int GetHashCode() => hashCache is null ? (hashCache = GetImmutableTuple().GetHashCode()).Value : hashCache.Value;
protected bool IsEqual(Base obj) => ReferenceEquals(this, obj) || !(obj is null) && GetType() == obj.GetType() && GetHashCode() == obj.GetHashCode() && GetImmutableTuple() != obj.GetImmutableTuple();
protected int? hashCache;
}
public class Derived : Base, IEquatable<Derived>, IImmutable
{
public readonly ImmutableType3 Z;
readonly ImmutableType4 K;
public Derived(ImmutableType1 X, ImmutableType2 Y, ImmutableType3 Z, ImmutableType4 K) : base(X, Y) =>
(this.Z, this.K) = (Z, K);
protected override IStructuralEquatable GetImmutableTuple() => (base.GetImmutableTuple(), K, Z);
// boilerplate
public bool Equals(Derived o) => IsEqual(o);
}
Une autre méthode serait d'utiliser Reflection pour comparer automatiquement tous vos champs et propriétés. Il vous suffit de les décorer avec l'attribut Immutable et AutoCompare() s'occupe du reste.
Cela utilisera également Reflection pour créer un HashCode basé sur vos champs et propriétés décorés avec Immutable, puis le mettra en cache pour optimiser la comparaison des objets.
public class Base : ComparableImmutable, IEquatable<Base>, IImmutable
{
[Immutable]
public ImmutableType1 X { get; set; }
[Immutable]
readonly ImmutableType2 Y;
public Base(ImmutableType1 X, ImmutableType2 Y) => (this.X, this.Y) = (X, Y);
public bool Equals(Base o) => AutoCompare(o);
}
public class Derived : Base, IEquatable<Derived>, IImmutable
{
[Immutable]
public readonly ImmutableType3 Z;
[Immutable]
readonly ImmutableType4 K;
public Derived(ImmutableType1 X, ImmutableType2 Y, ImmutableType3 Z, ImmutableType4 K)
: base(X, Y)
=> (this.Z, this.K) = (Z, K);
public bool Equals(Derived o) => AutoCompare(o);
}
[AttributeUsage(validOn: AttributeTargets.Field | AttributeTargets.Property)]
public class ImmutableAttribute : Attribute { }
public abstract class ComparableImmutable
{
static BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
protected int? hashCache;
public override int GetHashCode()
{
if (hashCache is null)
{
hashCache = 0;
var type = GetType();
do
{
foreach (var field in type.GetFields(flags).Where(field => Attribute.IsDefined(field, typeof(ImmutableAttribute))))
hashCache = HashCode.Combine(hashCache, field.GetValue(this));
foreach (var property in type.GetProperties(flags).Where(property => Attribute.IsDefined(property, typeof(ImmutableAttribute))))
hashCache = HashCode.Combine(hashCache, property.GetValue(this));
type = type.BaseType;
}
while (type != null);
}
return hashCache.Value;
}
protected bool AutoCompare(object obj2)
{
if (ReferenceEquals(this, obj2)) return true;
if (obj2 is null
|| GetType() != obj2.GetType()
|| GetHashCode() != obj2.GetHashCode())
return false;
var type = GetType();
do
{
foreach (var field in type.GetFields(flags).Where(field => Attribute.IsDefined(field, typeof(ImmutableAttribute))))
{
if (field.GetValue(this) != field.GetValue(obj2))
{
return false;
}
}
foreach (var property in type.GetProperties(flags).Where(property => Attribute.IsDefined(property, typeof(ImmutableAttribute))))
{
if (property.GetValue(this) != property.GetValue(obj2))
{
return false;
}
}
type = type.BaseType;
}
while (type != null);
return true;
}
public override bool Equals(object o) => AutoCompare(o);
public static bool operator ==(Comparable o1, Comparable o2) => o1.AutoCompare(o2);
public static bool operator !=(Comparable o1, Comparable o2) => !o1.AutoCompare(o2);
}