ObjectsComparer

You can compare ExpandoObject instances using the parameterless Comparer() constructor. The framework detects missing members and type mismatches across dynamic properties.

Configuration: By default, if a member exists in one object but not the other, it is reported as MissedMemberInSecondObject or MissedMemberInFirstObject. You can change this behavior using ComparisonSettings:

Set UseDefaultIfMemberNotExist = true to treat missing members as having a default value instead of reporting them as missing.

// Default behavior
dynamic a1 = new ExpandoObject();
a1.Field1 = "A";
dynamic a2 = new ExpandoObject();
a2.Field1 = "B";
var comparer = new Comparer();

// Using ComparisonSettings to treat missing members as default values
dynamic a1 = new ExpandoObject();
a1.Field1 = "A";
a1.Field2 = 0;
dynamic a2 = new ExpandoObject();
a2.Field1 = "B";
a2.Field4 = "S";
var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true });

For large projects, instead of configuring a Comparer manually every time, implement a ComparersFactory (inheriting from ComparersFactory). This allows you to centralize the logic for creating specialized comparers for specific types, including custom overrides and custom value comparers.

public class MyComparersFactory : ComparersFactory
{
    public override IComparer<T> GetObjectsComparer<T>(ComparisonSettings settings = null, IBaseComparer parentComparer = null)
    {
        if (typeof(T) == typeof(Person))
        {
            var comparer = new Comparer<Person>(settings, parentComparer, this);
            // Apply specific overrides for Person
            comparer.AddComparerOverride(() => new Person().PhoneNumber, new PhoneNumberComparer());
            return (IComparer<T>)comparer;
        }

        return base.GetObjectsComparer<T>(settings, parentComparer);
    }
}

// Usage
_factory = new MyComparersFactory();
_comparer = _factory.GetObjectsComparer<Person>();

The Comparer constructor accepts an optional ComparisonSettings object to control comparison behavior.

Available Settings

• RecursiveComparison (default: true): If true, non-primitive types that do not have a custom comparison rule or implement IComparable will be compared using the same rules as the root objects.
• EmptyAndNullEnumerablesEqual (default: false): If true, null values and empty enumerables (arrays, lists, etc.) are considered equal.
• UseDefaultIfMemberNotExist (default: false): Applicable for dynamic type comparisons. If true, a missing member is considered equal to the default value of the opposite member's type.

Custom Settings Storage

ComparisonSettings can also act as a key-value store for custom data used within your custom comparers:

• SetCustomSetting<T>(T value, string key = null)
• GetCustomSetting<T>(string key = null)

When comparing dynamic objects like those produced by JsonConvert.DeserializeObject<ExpandoObject>(json), use the parameterless Comparer constructor and provide overrides using string-based property names.

// Use UseDefaultIfMemberNotExist to handle missing keys gracefully
_comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true });

// Override by string name for dynamic properties
_comparer.AddComparerOverride("ConnectionString", DoNotCompareValueComparer.Instance);

// Use custom logic for specific dynamic fields
var urlComparer = new DynamicValueComparer<string>(
    (url1, url2, settings) => url1.Trim('/').Replace(@"http://", string.Empty) == url2.Trim('/').Replace(@"http://", string.Empty));
_comparer.AddComparerOverride("SomeUrl", urlComparer);

// Compare the ExpandoObjects
var isEqual = _comparer.Compare(settings0, settings1, out var differences);

By default, the comparer treats lists as different if their counts differ. To compare lists of items by their content (even if counts differ), implement AbstractComparer<T> (where T is the list type).

Inside CalculateDifferences, you can manually iterate through items, find matches based on a unique identifier (like an Id), and use a nested IComparer to compare the matched items. This allows you to report differences at specific paths like Items[Id=1].Property.

public class CustomFormulaItemsComparer : AbstractComparer<IList<FormulaItem>>
{
    public override IEnumerable<Difference> CalculateDifferences(IList<FormulaItem> obj1, IList<FormulaItem> obj2)
    {
        // ... handle nulls and count mismatches ...

        foreach (var formulaItem in obj1)
        {
            // Find matching item in second list by ID
            var formulaItem2 = obj2.FirstOrDefault(fi => fi.Id == formulaItem.Id);

            if (formulaItem2 != null)
            {
                // Use a standard comparer for the individual items
                var comparer = Factory.GetObjectsComparer<FormulaItem>();
                foreach (var difference in comparer.CalculateDifferences(formulaItem, formulaItem2))
                {
                    // Insert the ID into the path for clarity
                    yield return difference.InsertPath($"[Id={formulaItem.Id}]");
                }
            }
        }
    }
}