Comparing objects

Question

I have a class it contains some string members, some double members and some array objects.

I create two objects of this class, is there any simplest, efficient way of comparing these objects and say their equal? Any suggestions?

I know how to write a compare function, but will it be time consuming.

Answer 1

Just spent the whole day writing an extension method looping through reflecting over properties of an object with various complex bits of logic to deal with different property type and actually got it close to good, then at 16:55 it dawned on me that if you serialize the two object, you simply need compare the two strings ... duh

So here is a simple serializer extension method that even works on Dictionaries

    public static class TExtensions
    {
        public static string Serialize<T>(this T thisT)
        {
            var serializer = new DataContractSerializer(thisT.GetType());
            using (var writer = new StringWriter())
            using (var stm = new XmlTextWriter(writer))
            {
                serializer.WriteObject(stm, thisT);
                return writer.ToString();
            }
        }
}

Now your test can be as simple as

Asset.AreEqual(objA.Serialise(), objB.Serialise())

Haven't done extensive testing yet, but looks promising and more importantly, simple. Either way still a useful method to have in your utility set right ?

Answer 2

Since these are objects my guess is that you will have to override the Equals method for objects. Otherwise the Equals method will give you ok only if both objects refering to the same object.

I know this is not the answer you want. But since there is little number of properties in your class you can easily override the method.

Answer 3

The only way you can really do this is to override bool Object.Equals(object other) to return true when your conditions for equality are met, and return false otherwise. You must also override int Object.GetHashCode() to return an int computed from all of the data that you consider when overriding Equals().

As an aside, note that the contract for GetHashCode() specifies that the return value must be equal for two objects when Equals() would return true when comparing them. This means that return 0; is a valid implementation of GetHashCode() but it will cause inefficiencies when objects of your class are used as dictionary keys, or stored in a HashSet<T>.

The way I implement equality is like this:

public class Foo : IEquatable<Foo>
{
    public bool Equals(Foo other)
    {
        if (other == null)
            return false;

        if (other == this)
            return true; // Same object reference.

        // Compare this to other and return true/false as appropriate.
    }

    public override bool Equals(Object other)
    {
        return Equals(other as Foo);
    }

    public override int GetHashCode()
    {
        // Compute and return hash code.
    }
}

A simple way of implementing GetHashCode() is to XOR together the hash codes of all of the data you consider for equality in Equals(). So if, for example, the properties you compare for equality are string FirstName; string LastName; int Id;, your implementation might look like:

public override int GetHashCode()
{
    return (FirstName != null ? FirstName.GetHashCode() : 0) ^
        (LastName != null ? LastName.GetHashCode() : 0) ^
        Id; // Primitives of <= 4 bytes are their own hash codes
}

I typically do not override the equality operators, as most of the time I'm concerned with equality only for the purposes of dictionary keys or collections. I would only consider overriding the equality operators if you are likely to do more comparisons by value than by reference, as it is syntactically less verbose. However, you have to remember to change all places where you use == or != on your object (including in your implementation of Equals()!) to use Object.ReferenceEquals(), or to cast both operands to object. This nasty gotcha (which can cause infinite recursion in your equality test if you are not careful) is one of the primary reasons I rarely override these operators.

Answer 4

The 'proper' way to do it in .NET is to implement the IEquatable interface for your class:

public class SomeClass : IEquatable<SomeClass>
{
    public string Name { get; set; }
    public double Value { get; set; }
    public int[] NumberList { get; set; }

    public bool Equals(SomeClass other)
    {
        // whatever your custom equality logic is
        return other.Name == Name &&
            other.Value == Value &&
            other.NumberList == NumberList;
    }
}

However, if you really want to do it right, this isn't all you should do. You should also override the Equals(object, object) and GetHashCode(object) methods so that, no matter how your calling code is comparing equality (perhaps in a Dictionary or perhaps in some loosely-typed collection), your code and not reference-type equality will be the determining factor:

public class SomeClass : IEquatable<SomeClass>
{
    public string Name { get; set; }
    public double Value { get; set; }
    public int[] NumberList { get; set; }

    /// <summary>
    /// Explicitly implemented IEquatable method.
    /// </summary>
    public bool IEquatable<SomeClass>.Equals(SomeClass other)
    {
        return other.Name == Name &&
            other.Value == Value &&
            other.NumberList == NumberList;
    }

    public override bool Equals(object obj)
    {
        var other = obj as SomeClass;
        if (other == null)
            return false;
        return ((IEquatable<SomeClass>)(this)).Equals(other);
    }

    public override int GetHashCode()
    {
        // Determine some consistent way of generating a hash code, such as...
        return Name.GetHashCode() ^ Value.GetHashCode() ^ NumberList.GetHashCode();
    }
}

Answer 5

The best answer is to implement IEquatable for your class - it may not be the answer you want to hear, but that's the best way to implement value equivalence in .NET.

Another option would be computing a unique hash of all of the members of your class and then doing value comparisons against those, but that's even more work than writing a comparison function ;)