public abstract class Entity<TId>
    {
        public virtual TId Id { get; set; }

        public override bool Equals(object obj)
        {
            return Equals(obj as Entity<TId>);
        }

        private static bool IsTransient(Entity<TId> obj)
        {
            return obj != null &&
            Equals(obj.Id, default(TId));
        }

        public virtual Type GetUnproxiedType()
        {
            return GetType();
        }

        public virtual bool Equals(Entity<TId> other)
        {
            if (other == null)
                return false;
            if (ReferenceEquals(this, other))
                return true;
            if (!IsTransient(this) &&
            !IsTransient(other) &&
            Equals(Id, other.Id))
            {
                var otherType = other.GetUnproxiedType();
                var thisType = GetUnproxiedType();
                return thisType.IsAssignableFrom(otherType) ||
                otherType.IsAssignableFrom(thisType);
            }
            return false;
        }

        public override int GetHashCode()
        {
            if (Equals(Id, default(TId)))
                return base.GetHashCode();
            return Id.GetHashCode();
        }

        public static bool operator ==(Entity<TId> object1, Entity<TId> object2)
        {
            if ((object)object1== null)
            {
                return ((object)object2== null);
            }
            else
            {
                return object1.Equals(object2);
            }
        }

        public static bool operator !=(Entity<TId> object1, Entity<TId> object2)
        {
            return !(object1 == object2);
        }
    }

Имеется ввиду перегрузка оператора для сравнения экземпляров класса.