Please explain the technique used in this code to test Object Equality and Identity

Question

Please explain the technique used in this code to test Object Equality and Identity.

Better, if you can supply me any web-link/book-reference for detailed discussion.

[Serializable]
    public abstract class BusinessObject<T> : IBusinessObject where T : BusinessObject<T>
    {
        private int? requestedHashCode;

        public virtual int ID { get; set; }

        public virtual bool Equals(IBusinessObject other)
        {
            if (null == other || !GetType().IsInstanceOfType(other))
            {
                return false;
            }
            if (ReferenceEquals(this, other))
            {
                return true;
            }

            bool otherIsTransient = Equals(other.ID, default(T));
            bool thisIsTransient = IsTransient();
            if (otherIsTransient && thisIsTransient)
            {
                return ReferenceEquals(other, this);
            }

            return other.ID.Equals(ID);
        }

        protected bool IsTransient()
        {
            return Equals(ID, default(T));
        }

        public override bool Equals(object obj)
        {
            var that = obj as IBusinessObject;
            return Equals(that);
        }

        public override int GetHashCode()
        {
            if (!requestedHashCode.HasValue)
            {
                requestedHashCode = IsTransient() ? base.GetHashCode() : ID.GetHashCode();
            }
            return requestedHashCode.Value;
        }
}

What is a transient object?

Do you happen to have the code for the `Equals(object, object)` method? — Adam Houldsworth, Nov 04 '11 at 11:36
@AdamHouldsworth, it's the static overload of Object.Equals... — Thomas Levesque, Nov 04 '11 at 11:37
`Equals(other.ID, default(T))` makes no sense at all to me - that is comparing an `int` to a `BusinessObject`... — Marc Gravell, Nov 04 '11 at 11:40
I might be wrong, but IMO the "technique" here is called "badly written barely functioning code". — Marc Gravell, Nov 04 '11 at 11:50

score 3 · Accepted Answer · answered Nov 04 '11 at 11:41

3

it first checks if other is an instance of the same type as the current object. If not, they're not equal
it then performs a reference equality to check if other and the current object are the same instance. If they are, obviously they are equal
If both other and the current object are transient (i.e. not yet persisted), they don't have an ID, so they can't be compared by ID. Instead, they are compared by reference. (as noted by Marc Gravell in the comments, the test to check if the object is transient is broken; it doesn't make sense to compare an int to default(T))
Eventually, their IDs are compared; the objects are considered equal if they have the same ID

answered Nov 04 '11 at 11:41

Thomas Levesque

286,951
70
623
758

Can you supply me with any external reference? – user366312 Nov 04 '11 at 13:58
What kind of external reference do you need? You can look at the [documentation for Object.Equals](http://msdn.microsoft.com/en-us/library/bsc2ak47.aspx), but the implementation itself is specific to your app domain... – Thomas Levesque Nov 04 '11 at 14:34
Reference about database id-column based Equality/Identity testing in C#. – user366312 Nov 06 '11 at 08:11
@Saqib, I don't know if there is any reference about that... it's not really a C# question: usually database entities with the same key are considered equal, because they're supposed to represent the same entity (otherwise, what would be the point of having a key in the first place?) – Thomas Levesque Nov 06 '11 at 11:17

score 2 · Answer 2 · answered Nov 04 '11 at 11:44

I think what the code is trying to do is say "has it got an ID yet", i.e. a "transient" object might (if I read the code's intent correctly) be one that is not yet saved to the DB. Then equality is defined as:

if it has an ID, does it match? (even for different instances of the same type)
if it doesn't have an ID, is it the same object instance (reference)

unfortunately the implementation looks completely broken, as Equals(ID, default(T)) is meaningless when T is something completely different (a BusinessObject<T>) - hence default(T) will always be null and ID will never be null (it is not nullable). So nothing will ever report as transient.

Additionally, this code:

if (null == other || !GetType().IsInstanceOfType(other))

is hugely inefficient. I suspect something involving as would be far preferable, but again: the code looks so... tortured... that I'm loathe to second-guess the intent.

Please explain the technique used in this code to test Object Equality and Identity

2 Answers2