Finding property differences between two C# objects

.net, auditing, c#, reflection

Solution

`IComparable` is for ordering comparisons. Either use `IEquatable` instead, or just use the static `System.Object.Equals` method. The latter has the benefit of also working if the object is not a primitive type but still defines its own equality comparison by overriding `Equals`.

object originalValue = property.GetValue(originalObject, null);
object newValue = property.GetValue(changedObject, null);
if (!object.Equals(originalValue, newValue))
{
    string originalText = (originalValue != null) ?
        originalValue.ToString() : "[NULL]";
    string newText = (newText != null) ?
        newValue.ToString() : "[NULL]";
    // etc.
}

This obviously isn't perfect, but if you're only doing it with classes that you control, then you can make sure it always works for your particular needs.

There are other methods to compare objects (such as checksums, serialization, etc.) but this is probably the most reliable if the classes don't consistently implement `IPropertyChanged` and you want to actually know the differences.

Update for new example code:

Address address1 = new Address();
address1.StateProvince = new StateProvince();

Address address2 = new Address();
address2.StateProvince = new StateProvince();

IList list = Utility.GenerateAuditLogMessages(address1, address2);

The reason that using `object.Equals` in your audit method results in a "hit" is because the instances are actually not equal!

Sure, the `StateProvince` may be empty in both cases, but `address1` and `address2` still have non-null values for the `StateProvince` property and each instance is different. Therefore, `address1` and `address2` have different properties.

Let's flip this around, take this code as an example:

Address address1 = new Address("35 Elm St");
address1.StateProvince = new StateProvince("TX");

Address address2 = new Address("35 Elm St");
address2.StateProvince = new StateProvince("AZ");

Should these be considered equal? Well, they will be, using your method, because `StateProvince` does not implement `IComparable`. That's the only reason why your method reported that the two objects were the same in the original case. Since the `StateProvince` class does not implement `IComparable`, the tracker just skips that property entirely. But these two addresses are clearly not equal!

This is why I originally suggested using `object.Equals`, because then you can override it in the `StateProvince` method to get better results:

public class StateProvince
{
    public string Code { get; set; }

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

        StateProvince sp = obj as StateProvince;
        if (object.ReferenceEquals(sp, null))
            return false;

        return (sp.Code == Code);
    }

    public bool Equals(StateProvince sp)
    {
        if (object.ReferenceEquals(sp, null))
            return false;

        return (sp.Code == Code);
    }

    public override int GetHashCode()
    {
        return Code.GetHashCode();
    }

    public override string ToString()
    {
        return string.Format("Code: [{0}]", Code);
    }
}

Once you've done this, the `object.Equals` code will work perfectly. Instead of naïvely checking whether or not `address1` and `address2` literally have the same `StateProvince` reference, it will actually check for semantic equality.

The other way around this is to extend the tracking code to actually descend into sub-objects. In other words, for each property, check the `Type.IsClass` and optionally the `Type.IsInterface` property, and if `true`, then recursively invoke the change-tracking method on the property itself, prefixing any audit results returned recursively with the property name. So you'd end up with a change for `StateProvinceCode`.

I use the above approach sometimes too, but it's easier to just override `Equals` on the objects for which you want to compare semantic equality (i.e. audit) and provide an appropriate `ToString` override that makes it clear what changed. It doesn't scale for deep nesting but I think it's unusual to want to audit that way.

The last trick is to define your own interface, say `IAuditable<T>`, which takes a second instance of the same type as a parameter and actually returns a list (or enumerable) of all of the differences. It's similar to our overridden `object.Equals` method above but gives back more information. This is useful for when the object graph is really complicated and you know you can't rely on Reflection or `Equals`. You can combine this with the above approach; really all you have to do is substitute `IComparable` for your `IAuditable` and invoke the `Audit` method if it implements that interface.

Problem

Original source

Related problems

• Comparing object properties in c#