如何优雅地检查类层次结构中的相等性，这些类具有一个包含主键的公共基类 class？

Question

Background

I have a base class which holds an integer ID that is used for ORM (Microsoft Entity Framework). There are about 25 classes derived from this, and the inheritance hierarchy is up to 4 classes deep.

Requirement

I need to be able to test if an object in this hierarchy is equal to another object. To be equal it is necessary but not sufficient for the IDs to be the same. For example, if two Person objects have different IDs then they are not equal, but if they have the same ID then they may or may not be equal.

Algorithm

In order to implement the C# Equals method you have to check that:

• The Supplied object is not null.
• It must be of the same type as this object
• The ID s must match

In addition to this, all other attributes must be compared, except in the special case where the two objects are identical.

Implementation

    /// <summary>
    /// An object which is stored in the database
    /// </summary>
    public abstract class DatabaseEntity
    {
        /// <summary>
        /// The unique identifier; if zero (0) then the ID is not assigned
        /// </summary>
        public int ID { get; set; }

        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return false;
            }

            if (ReferenceEquals(obj, this))
            {
                return true;
            }

            if (obj.GetType() != GetType())
            {
                return false;
            }

            DatabaseEntity databaseEntity = (DatabaseEntity)obj;
            if (ID != databaseEntity.ID)
            {
                return false;
            }

            return EqualsIgnoringID(databaseEntity);
        }

        public override int GetHashCode()
        {
            return ID;
        }

        /// <summary>
        /// Check if this object is equal to the supplied one, disregarding the IDs
        /// </summary>
        /// <param name="databaseEntity">another object, which should be of the same type as this one</param>
        /// <returns>true if they are equal (disregarding the ID)</returns>
        protected abstract bool EqualsIgnoringID(DatabaseEntity databaseEntity);
    }

    public class Person : DatabaseEntity
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public override bool EqualsIgnoringID(DatabaseEntity databaseEntity)
        {
            Person person = (Person)databaseEntity;
            return person.FirstName == FirstName && person.LastName == LastName;
        }
    }

    public class User: Person
    {
        public string Password { get; set; }

        public override bool EqualsIgnoringID(DatabaseEntity databaseEntity)
        {
            User user = (User)databaseEntity;
            return user.Password == Password;
        }
    }

Comments

The feature of this solution that I dislike the most is the explicit conversions. Is there an alternative solution, which avoids having to repeat all the common logic (checking for null, type etc) in each class?

Answer 1

This is pretty easy using generics:

public abstract class Entity<T>
{
  protected abstract bool IsEqual(T other);
}

public class Person : Entity<Person>
{
  protected override bool IsEqual(Person other) { ... }
}

This works fine for one level of inheritance, or when all the levels are abstract except for the last one.

If that's not good enough for you, you have a decision to make:

• If it's not all that common, it might be just fine to keep the few exceptions with manual casts.
• If it is common, you're out of luck. Making Person generic works, but it kind of defeats the purpose - it requires you to specify the concrete Person -derived type whenever you need to use Person . This can be handled by having an interface IPerson that's not generic. Of course, in effect, this still means that Person is abstract - you have no way of constructing a non-concrete version of Person . Why wouldn't it be abstract, in fact? Can you have a Person that isn't one of the derived types of Person ? That sounds like a bad idea.

Answer 2

It seems simpler if instead of using abstract , you just keep overriding the Equals method for subclasses. Then you can extend like this:

public class Person : DatabaseEntity
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public override bool Equals(object other)
    {
        if (!base.Equals(other))
            return false;
        Person person = (Person)other;
        return person.FirstName == FirstName && person.LastName == LastName;
    }
}

You have to cast to Person , but this works with relatively few lines of code and with long hierarchies without any worries. (Because you already checked for the runtime types being the same in the very root of the hierarchy, you don't even have to do a as Person with a null check.)

---

As mentioned in the comments, with the above approach you can't stop evaluating (short-circuit) if you know for certain this is equal to other . (Although you do short-circuit if you know for sure this is not equal to other .) For example, if this has reference equality with other , you can short-circuit because there's no doubt that an object is equal to itself.

Being able to return early would mean that you can skip a lot of checks. This is useful if the checks are expensive.

To allow Equals to short-circuit true as well as false , we can add a new equality method that returns bool? to represent three states:

• true : this is definitely equal to other without any need to check derived classes' properties. (Short-circuit.)
• false : this is definitely not equal to other without any need to check derived classes' properties. (Short-circuit.)
• null : this might or might not be equal to other , depending on derived classes' properties. ( Do not short-circuit.)

Since this doesn't match the bool of Equals , you need to define Equals in terms of BaseEquals . Each derived class checks its base class' BaseEquals and chooses to short circuit if an answer is already definite ( true or false ) and if not, find out if the current class proves inequality. In Equals , then, a null means that no class in the inheritance hierarchy could determine inequality, so the two objects are equal and Equals should return true . Here's an implementation that will hopefully explain this better:

public class DatabaseEntity
{
    public int ID { get; set; }

    public override bool Equals(object other)
    {
        // Turn a null answer into true: if the most derived class has not
        // eliminated the possibility of equality, this and other are equal.
        return BaseEquals(other) ?? true;
    }

    protected virtual bool? BaseEquals(object other)
    {
        if (other == null)
            return false;
        if (ReferenceEquals(this, other))
            return true;
        if (GetType() != other.GetType())
            return false;

        DatabaseEntity databaseEntity = (DatabaseEntity)other;
        if (ID != databaseEntity.ID)
            return false;
        return null;
    }
}

public class Person : DatabaseEntity
{
    public string FirstName { get; set; }
    public string LastName { get; set; }

    protected override bool? BaseEquals(object other)
    {
        bool? baseEquals = base.BaseEquals(other);
        if (baseEquals != null)
            return baseEquals;

        Person person = (Person)other;
        if (person.FirstName != FirstName || person.LastName != LastName)
            return false;
        return null;
    }
}

Answer 3

Well here is a variant of @31eee384 one's.

I don't use it's trinary abstract method. I suppose that if base.Equals() return true , I still need to perform the derived Equals checks too.

The drawback though is that you renounce to have the Reference Equality in base.Equals to propagate this "short-circuit" in derived classes Equals method.

Maybe there exists something in C# to "force to stop" the overriding somehow and "hard return true" when the reference equality is true without continuing the overridden derived Equals calls.

Also do note that following 31eee384 answer, we give up the template method pattern used by OP. Using this pattern again actually goes back to OP's implementation.

public class Base : IEquatable<Base>
{
    public int ID {get; set;}

    public Base(int id)
    {ID = id;}

    public virtual bool Equals(Base other)
    {
        Console.WriteLine("Begin Base.Equals(Base other);");
    
        if (other == null) return false;
        if (ReferenceEquals(this, other)) return true;
        if (GetType() != other.GetType()) return false;
    
        return ID == other.ID;
    }

    public override bool Equals(object other)
    {
        return this.Equals(other as Base);
    }

    public override int GetHashCode()
    {
        unchecked
        {
            // Choose large primes to avoid hashing collisions
            const int HashingBase = (int) 2166136261;
            const int HashingMultiplier = 16777619;

            int hash = HashingBase;
            hash = (hash * HashingMultiplier) ^ (!Object.ReferenceEquals(null, ID) ? ID.GetHashCode() : 0);        
            return hash;
        }
    }

    public override string ToString()
    {
        return "A Base object with ["+ID+"] as ID";
    }
}

public class Derived : Base, IEquatable<Derived>
{
    public string Name {get; set;}

    public Derived(int id, string name) : base(id)
    {Name = name;}

    public bool Equals(Derived other)
    {   
        Console.WriteLine("Begin Derived.Equals(Derived other);");
    
        if (!base.Equals(other)) return false;
    
        return Name == other.Name;
    }

    public override bool Equals(object other)
    {
        return this.Equals(other as Derived);
    }   
    
    public override int GetHashCode()
    {
        unchecked
        {
            // Choose large primes to avoid hashing collisions
            const int HashingBase = (int) 2166136261;
            const int HashingMultiplier = 16777619;

            int hash = HashingBase;
            hash = (hash * HashingMultiplier) ^ base.GetHashCode();
            hash = (hash * HashingMultiplier) ^ (!Object.ReferenceEquals(null, Name) ? Name.GetHashCode() : 0);        
            return hash;
        }
    }

    public override string ToString()
    {
        return "A Derived object with '" + Name + "' as Name, and also " + base.ToString();
    }
}

Here is my fiddle link .