Repository: ValeraT1982/ObjectsComparer Branch: master Commit: b106e48c4679 Files: 126 Total size: 369.9 KB Directory structure: gitextract_agfyhd9m/ ├── .gitignore ├── LICENSE ├── ObjectsComparer/ │ ├── ObjectsComparer/ │ │ ├── AbstractComparer.cs │ │ ├── AbstractComparer~1.cs │ │ ├── Attributes/ │ │ │ └── IgnoreInComparisonAttribute.cs │ │ ├── BaseComparer.cs │ │ ├── Comparer.cs │ │ ├── ComparerOverridesCollection.cs │ │ ├── ComparersFactory.cs │ │ ├── Comparer~1.cs │ │ ├── ComparisonSettings.cs │ │ ├── CustomComparers/ │ │ │ ├── AbstractDynamicObjectsComprer.cs │ │ │ ├── AbstractEnumerablesComparer.cs │ │ │ ├── CompilerGeneratedObjectComparer.cs │ │ │ ├── DynamicObjectComparer.cs │ │ │ ├── EnumerablesComparer.cs │ │ │ ├── EnumerablesComparer~1.cs │ │ │ ├── ExpandoObjectComparer.cs │ │ │ ├── GenericEnumerablesComparer.cs │ │ │ ├── HashSetsComparer.cs │ │ │ ├── HashSetsComparer~1.cs │ │ │ ├── IComparerWithCondition.cs │ │ │ ├── MultidimensionalArrayComparer~1.cs │ │ │ ├── MultidimensionalArraysComparer.cs │ │ │ └── TypesComparer.cs │ │ ├── Difference.cs │ │ ├── DifferenceTypes.cs │ │ ├── Exceptions/ │ │ │ ├── AmbiguousComparerOverrideResolutionException.cs │ │ │ └── ValueComparerExistsException.cs │ │ ├── IBaseComparer.cs │ │ ├── IComparer.cs │ │ ├── IComparersFactory.cs │ │ ├── IComparer~1.cs │ │ ├── LICENSE │ │ ├── ObjectsComparer.csproj │ │ ├── ObjectsComparer.csproj.DotSettings │ │ ├── Properties/ │ │ │ └── AssemblyInfo.cs │ │ ├── Utils/ │ │ │ ├── MemberInfoExtensions.cs │ │ │ ├── PropertyHelper.cs │ │ │ └── TypeExtensions.cs │ │ └── ValueComparers/ │ │ ├── AbstractValueComparer.cs │ │ ├── AbstractValueComparer~1.cs │ │ ├── DefaultValueComparer.cs │ │ ├── DefaultValueValueComparer.cs │ │ ├── DoNotCompareValueComparer.cs │ │ ├── DynamicValueComparer.cs │ │ ├── IValueComparer.cs │ │ ├── IValueComparer~1.cs │ │ ├── IgnoreCaseStringsValueComparer.cs │ │ ├── NulableStringsValueComparer.cs │ │ ├── ToStringComparer.cs │ │ └── UriComparer.cs │ ├── ObjectsComparer.Examples/ │ │ ├── BasicExamples/ │ │ │ ├── BasicExampleTests.cs │ │ │ └── ClassA.cs │ │ ├── Example1/ │ │ │ ├── Error.cs │ │ │ ├── Example1Tests.cs │ │ │ └── Message.cs │ │ ├── Example2/ │ │ │ ├── Example2Tests.cs │ │ │ ├── MyComparersFactory.cs │ │ │ ├── Person.cs │ │ │ └── PhoneNumberComparer.cs │ │ ├── Example3/ │ │ │ ├── Example3Tests.cs │ │ │ ├── Settings0.json │ │ │ ├── Settings1.json │ │ │ └── Settings2.json │ │ ├── Example4/ │ │ │ ├── CustomFormulaItemsComparer.cs │ │ │ ├── Example4Tests.cs │ │ │ ├── Formula.cs │ │ │ ├── FormulaItem.cs │ │ │ └── MyComparersFactory.cs │ │ ├── Example5/ │ │ │ ├── Error.cs │ │ │ ├── Example5Tests.cs │ │ │ └── IgnoreAttribute.cs │ │ ├── ObjectsComparer.Examples.csproj │ │ └── OutputHelper.cs │ ├── ObjectsComparer.Tests/ │ │ ├── AbstractComparerGenericTests.cs │ │ ├── AbstractComparerTests.cs │ │ ├── ComparerNonGenericTests.cs │ │ ├── ComparerOverridesCollectionTests.cs │ │ ├── ComparerTests.cs │ │ ├── Comparer_CompilerGeneratedObjectsTests.cs │ │ ├── Comparer_DynamicObjectsTests.cs │ │ ├── Comparer_ExpandoObjectsTests.cs │ │ ├── Comparer_GenericEnumerableTests.cs │ │ ├── Comparer_IPEndPointTests.cs │ │ ├── Comparer_Issue24Tests.cs │ │ ├── Comparer_MultidimensionalArraysTests.cs │ │ ├── Comparer_NonGenericEnumerableTests.cs │ │ ├── Comparer_OverridesTests.cs │ │ ├── Comparer_StringBuilderTests.cs │ │ ├── Comparer_UriTests.cs │ │ ├── ComparersFactoryTests.cs │ │ ├── ComparisonSettingsTests.cs │ │ ├── CustomComparers/ │ │ │ ├── AbstractValueComparerTests.cs │ │ │ ├── DynamicValueComparerTests.cs │ │ │ ├── EnumerablesComparerGenericTests.cs │ │ │ ├── EnumerablesComparerTests.cs │ │ │ ├── HashSetsComparerTests.cs │ │ │ └── TypesComparerTests.cs │ │ ├── DifferenceTests.cs │ │ ├── ObjectsComparer.Tests.csproj │ │ ├── ObjectsComparer.Tests.csproj.DotSettings │ │ ├── ParentInterfacePropertiesTests.cs │ │ ├── TestClasses/ │ │ │ ├── A.cs │ │ │ ├── B.cs │ │ │ ├── Child.cs │ │ │ ├── CollectionOfB.cs │ │ │ ├── EnumerableImplementation.cs │ │ │ ├── FlagsEnum.cs │ │ │ ├── ITestInterface.cs │ │ │ ├── InheritedFromB.cs │ │ │ ├── MultidimensionalArrays.cs │ │ │ ├── Parent.cs │ │ │ ├── ParentChild.cs │ │ │ ├── TestEnum.cs │ │ │ ├── TestInterfaceImplementation1.cs │ │ │ ├── TestInterfaceImplementation2.cs │ │ │ └── TestStruct.cs │ │ ├── Utils/ │ │ │ └── TypeExtensionsTests.cs │ │ └── ValueComparers/ │ │ ├── DefaultValueComparerTests.cs │ │ ├── DefaultValueValueComparerTests.cs │ │ ├── DoNotCompareValueComparerTests.cs │ │ ├── IgnoreCaseStringsValueComparerTests.cs │ │ └── NulableStringsValueComparerTests.cs │ └── ObjectsComparer.sln └── README.md ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # User-specific files *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ # Visual Studio 2015 cache/options directory .vs/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUNIT *.VisualState.xml TestResult.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # DNX project.lock.json artifacts/ *_i.c *_p.c *_i.h *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *.log *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db *.VC.VC.opendb # Visual Studio profiler *.psess *.vsp *.vspx *.sap # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # JustCode is a .NET coding add-in .JustCode # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # TODO: Comment the next line if you want to checkin your web deploy settings # but database connection strings (with potential passwords) will be unencrypted *.pubxml *.publishproj # Microsoft Azure Web App publish settings. Comment the next line if you want to # checkin your Azure Web App publish settings, but sensitive information contained # in these scripts will be unencrypted PublishScripts/ # NuGet Packages *.nupkg # The packages folder can be ignored because of Package Restore **/packages/* # except build/, which is used as an MSBuild target. !**/packages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/packages/repositories.config # NuGet v3's project.json files produces more ignoreable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Windows Store app package directories and files AppPackages/ BundleArtifacts/ Package.StoreAssociation.xml _pkginfo.txt # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !*.[Cc]ache/ # Others ClientBin/ ~$* *~ *.dbmdl *.dbproj.schemaview *.pfx *.publishsettings node_modules/ orleans.codegen.cs # Since there are multiple workflows, uncomment next line to ignore bower_components # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) #bower_components/ # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm # SQL Server files *.mdf *.ldf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/ModelManifest.xml **/*.Server/GeneratedArtifacts **/*.Server/ModelManifest.xml _Pvt_Extensions # Paket dependency manager .paket/paket.exe paket-files/ # FAKE - F# Make .fake/ # JetBrains Rider .idea/ *.sln.iml ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2019 Valerii Tereshchenko Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: ObjectsComparer/ObjectsComparer/AbstractComparer.cs ================================================ using System; using System.Collections.Generic; using System.Linq; namespace ObjectsComparer { /// /// Implementation of which provides implementation of Compare methods. /// public abstract class AbstractComparer: BaseComparer, IComparer { protected AbstractComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public abstract IEnumerable CalculateDifferences(Type type, object obj1, object obj2); /// /// Calculates list of differences between objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences between objects. public IEnumerable CalculateDifferences(T obj1, T obj2) { return CalculateDifferences(typeof(T), obj1, obj2); } /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences. /// True if objects are equal, otherwise false. public bool Compare(Type type, object obj1, object obj2, out IEnumerable differences) { differences = CalculateDifferences(type, obj1, obj2); return !differences.Any(); } /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// True if objects are equal, otherwise false. public bool Compare(Type type, object obj1, object obj2) { return !CalculateDifferences(type, obj1, obj2).Any(); } /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences. /// True if objects are equal, otherwise false. public bool Compare(T obj1, T obj2, out IEnumerable differences) { return Compare(typeof(T), obj1, obj2, out differences); } /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// True if objects are equal, otherwise false. public bool Compare(T obj1, T obj2) { return Compare(typeof(T), obj1, obj2); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/AbstractComparer~1.cs ================================================ using System.Collections.Generic; using System.Linq; namespace ObjectsComparer { /// /// Implementation of which provides implementation of Compare methods. /// public abstract class AbstractComparer: BaseComparer, IComparer { protected AbstractComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) :base(settings, parentComparer, factory) { } /// /// Compares objects. /// /// Object 1. /// Object 2. /// List of differences. /// True if objects are equal, otherwise false. public bool Compare(T obj1, T obj2, out IEnumerable differences) { differences = CalculateDifferences(obj1, obj2); return !differences.Any(); } /// /// Compares objects. /// /// Object 1. /// Object 2. /// True if objects are equal, otherwise false. public bool Compare(T obj1, T obj2) { return !CalculateDifferences(obj1, obj2).Any(); } /// /// Calculates list of differences between objects. /// /// Object 1. /// Object 2. /// List of differences between objects. public abstract IEnumerable CalculateDifferences(T obj1, T obj2); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Attributes/IgnoreInComparisonAttribute.cs ================================================ // *********************************************************************** // Assembly : Objects Comparer // Author : Ankur Kumar Gupta // Created : 24-Feb-2022 // *********************************************************************** namespace ObjectsComparer.Attributes { using System; /// /// Class is used to specify whether the element on which it is applied will have comparison effect /// [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)] public sealed class IgnoreInComparisonAttribute : Attribute { } } ================================================ FILE: ObjectsComparer/ObjectsComparer/BaseComparer.cs ================================================ using System; using System.Linq.Expressions; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { /// /// Provides base implementation to configure comparer. /// public abstract class BaseComparer: IBaseComparer { /// /// Comparison Settings. /// public ComparisonSettings Settings { get; } /// /// Default /// public IValueComparer DefaultValueComparer { get; private set; } protected IComparersFactory Factory { get; } internal ComparerOverridesCollection OverridesCollection { get; } = new ComparerOverridesCollection(); protected BaseComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) { Factory = factory ?? new ComparersFactory(); Settings = settings ?? new ComparisonSettings(); DefaultValueComparer = new DefaultValueComparer(); // ReSharper disable once InvertIf if (parentComparer != null) { DefaultValueComparer = parentComparer.DefaultValueComparer; OverridesCollection.Merge(parentComparer.OverridesCollection); } } /// /// Adds Comparer Override by Type. /// /// Type. /// Value Comparer. /// Value Comparer will be used only if filter(memberInfo) == true. Null by default. public void AddComparerOverride(Type type, IValueComparer valueComparer, Func filter = null) { OverridesCollection.AddComparer(type, valueComparer, filter); } /// /// Adds Comparer Override by member filter. /// /// Value Comparer. /// Value Comparer will be used only if filter(memberInfo) == true. public void AddComparerOverride(IValueComparer valueComparer, Func filter) { OverridesCollection.AddComparer(valueComparer, filter); } /// /// Adds Comparer Override by Type. /// /// Type. /// Value Comparer. /// Value Comparer will be used only if filter(memberInfo) == true. Null by default. public void AddComparerOverride(IValueComparer valueComparer, Func filter = null) { AddComparerOverride(typeof(TType), valueComparer, filter); } /// /// Adds Comparer Override by Member. /// /// Type of the member. /// Lambda to get member. /// Value Comparer. public void AddComparerOverride(Expression> memberLambda, IValueComparer valueComparer) { OverridesCollection.AddComparer(PropertyHelper.GetMemberInfo(memberLambda), valueComparer); } /// /// Adds Comparer Override by Member. /// /// Type of the member. /// Lambda to get member. /// Function to compare objects. /// Function to convert objects to string. public void AddComparerOverride( Expression> memberLambda, Func compareFunction, Func toStringFunction) { OverridesCollection.AddComparer( PropertyHelper.GetMemberInfo(memberLambda), new DynamicValueComparer( compareFunction, toStringFunction)); } /// /// Adds Comparer Override by Member. /// /// Type of the member. /// Lambda to get member. /// Function to compare objects. public void AddComparerOverride( Expression> memberLambda, Func compareFunction) { OverridesCollection.AddComparer( PropertyHelper.GetMemberInfo(memberLambda), new DynamicValueComparer( compareFunction, obj => obj?.ToString())); } /// /// Adds Comparer Override by Member. /// /// Member Info. /// Value Comparer. public void AddComparerOverride(MemberInfo memberInfo, IValueComparer valueComparer) { OverridesCollection.AddComparer(memberInfo, valueComparer); } /// /// Adds Comparer Override by Member name. /// /// Member Name. /// Value Comparer. /// Value Comparer will be used only if filter(memberInfo) == true. Null by default. public void AddComparerOverride(string memberName, IValueComparer valueComparer, Func filter = null) { OverridesCollection.AddComparer(memberName, valueComparer, filter); } /// /// Sets . /// /// Value Comparer. public void SetDefaultComparer(IValueComparer valueComparer) { DefaultValueComparer = valueComparer ?? throw new ArgumentNullException(nameof(valueComparer)); } /// /// Ignors comparison for Type. /// /// Type. public void IgnoreMember() { OverridesCollection.AddComparer(typeof(TType), DoNotCompareValueComparer.Instance); } /// /// Ignors comparison for Member. /// /// Type of the member. public void IgnoreMember(Expression> memberLambda) { OverridesCollection.AddComparer( PropertyHelper.GetMemberInfo(memberLambda), DoNotCompareValueComparer.Instance); } /// /// Ignors comparison for Member by Member name. /// /// Member Name. public void IgnoreMember(string memberName) { OverridesCollection.AddComparer(memberName, DoNotCompareValueComparer.Instance); } /// /// Ignors comparison by Member filter. /// /// Member will be ignored if filter(memberInfo) == true. public void IgnoreMember(Func filter) { OverridesCollection.AddComparer(DoNotCompareValueComparer.Instance, filter); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Comparer.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { /// /// Compares objects. /// public class Comparer : AbstractComparer { private static string CalculateDifferencesMethodName { // ReSharper disable once IteratorMethodResultIsIgnored get { return MemberInfoExtensions.GetMethodName>(x => x.CalculateDifferences(null, null)); } } /// /// Initializes a new instance of the class. /// /// Comparison Settings. /// Parent Comparer. Is used to copy DefaultValueComparer and Overrides. Null by default. /// Factory to create comparers in case of some members of the objects will need it. public Comparer(ComparisonSettings settings = null, BaseComparer parentComparer = null, IComparersFactory factory = null) : base(settings, parentComparer, factory) { } /// /// Calculates list of differences between objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences between objects. public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { var objectsComparerMethod = typeof(IComparersFactory).GetTypeInfo().GetMethods().First(m => m.IsGenericMethod); var objectsComparerGenericMethod = objectsComparerMethod.MakeGenericMethod(type); var comparer = objectsComparerGenericMethod.Invoke(Factory, new object[] { Settings, this }); var genericType = typeof(IComparer<>).MakeGenericType(type); var method = genericType.GetTypeInfo().GetMethod(CalculateDifferencesMethodName, new[] { type, type }); // ReSharper disable once PossibleNullReferenceException return (IEnumerable)method.Invoke(comparer, new[] { obj1, obj2 }); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ComparerOverridesCollection.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using ObjectsComparer.Exceptions; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class ComparerOverridesCollection { private class ValueComparerWithFilter { public IValueComparer ValueComparer { get; } public Func Filter { get; } public ValueComparerWithFilter(IValueComparer valueComparer, Func filter) { Filter = filter; ValueComparer = valueComparer; } } private readonly List, IValueComparer>> _overridesByMemberFilter = new List, IValueComparer>>(); private readonly Dictionary _overridesByMember = new Dictionary(); private readonly Dictionary> _overridesByType = new Dictionary>(); private readonly Dictionary> _overridesByName = new Dictionary>(); public void AddComparer(MemberInfo memberInfo, IValueComparer valueComparer) { if (memberInfo == null) { throw new ArgumentNullException(nameof(memberInfo)); } if (_overridesByMember.ContainsKey(memberInfo)) { throw new ValueComparerExistsException(memberInfo); } _overridesByMember[memberInfo] = valueComparer ?? throw new ArgumentNullException(nameof(valueComparer)); } public void AddComparer(IValueComparer valueComparer, Func filter) { if (filter == null) { throw new ArgumentNullException(nameof(filter)); } _overridesByMemberFilter.Add(new Tuple, IValueComparer>(filter, valueComparer)); } public void AddComparer(Type type, IValueComparer valueComparer, Func filter = null) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (valueComparer == null) { throw new ArgumentNullException(nameof(valueComparer)); } if (!_overridesByType.ContainsKey(type)) { _overridesByType[type] = new List(); } if (!_overridesByType[type].Any(comparer => comparer.ValueComparer == valueComparer && comparer.Filter == filter)) { _overridesByType[type].Add(new ValueComparerWithFilter(valueComparer, filter)); } } public void AddComparer(string memberName, IValueComparer valueComparer, Func filter = null) { if (string.IsNullOrWhiteSpace(memberName)) { throw new ArgumentException($"{nameof(memberName)} cannot be null or empty"); } if (valueComparer == null) { throw new ArgumentNullException(nameof(valueComparer)); } if (!_overridesByName.ContainsKey(memberName)) { _overridesByName[memberName] = new List(); } _overridesByName[memberName].Add(new ValueComparerWithFilter(valueComparer, filter)); } public void Merge(ComparerOverridesCollection collection) { foreach (var overridePair in collection._overridesByMember) { AddComparer(overridePair.Key, overridePair.Value); } foreach (var overrideCollection in collection._overridesByType) { foreach (var overridePair in overrideCollection.Value) { AddComparer(overrideCollection.Key, overridePair.ValueComparer, overridePair.Filter); } } foreach (var overrideCollection in collection._overridesByName) { foreach (var overridePair in overrideCollection.Value) { AddComparer(overrideCollection.Key, overridePair.ValueComparer, overridePair.Filter); } } foreach (var memberFilterOverride in collection._overridesByMemberFilter) { AddComparer(memberFilterOverride.Item2, memberFilterOverride.Item1); } } public IValueComparer GetComparer(Type type) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (!_overridesByType.TryGetValue(type, out var overridesByType)) { return null; } overridesByType = overridesByType.Where(o => o.Filter == null).ToList(); if (overridesByType.Count > 1) { throw new AmbiguousComparerOverrideResolutionException(type); } return overridesByType.Count == 1 ? overridesByType[0].ValueComparer : null; } public IValueComparer GetComparer(MemberInfo memberInfo) { if (memberInfo == null) { throw new ArgumentNullException(nameof(memberInfo)); } if (_overridesByMember.TryGetValue(memberInfo, out var overrideByMemberInfo)) { return overrideByMemberInfo; } var memberFilterOverride = _overridesByMemberFilter.Find(t => t.Item1(memberInfo))?.Item2; if (memberFilterOverride != null) { return memberFilterOverride; } if (_overridesByName.TryGetValue(memberInfo.Name, out var overridesByName)) { overridesByName = overridesByName.Where(o => o.Filter == null || o.Filter(memberInfo)).ToList(); if (overridesByName.Count > 1) { throw new AmbiguousComparerOverrideResolutionException(memberInfo); } if (overridesByName.Count == 1) { return overridesByName[0].ValueComparer; } } if (_overridesByType.TryGetValue(memberInfo.GetMemberType(), out var overridesByType)) { overridesByType = overridesByType.Where(o => o.Filter == null || o.Filter(memberInfo)).ToList(); if (overridesByType.Count > 1) { throw new AmbiguousComparerOverrideResolutionException(memberInfo); } if (overridesByType.Count == 1) { return overridesByType[0].ValueComparer; } } return null; } public IValueComparer GetComparer(string memberName) { if (string.IsNullOrWhiteSpace(memberName)) { throw new ArgumentNullException(nameof(memberName)); } if (!_overridesByName.TryGetValue(memberName, out var overridesByName)) { return null; } overridesByName = overridesByName.Where(o => o.Filter == null).ToList(); if (overridesByName.Count > 1) { throw new AmbiguousComparerOverrideResolutionException(memberName); } return overridesByName.Count == 1 ? overridesByName[0].ValueComparer : null; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ComparersFactory.cs ================================================ using System; namespace ObjectsComparer { /// /// Implements Comparers Factory. /// public class ComparersFactory : IComparersFactory { /// /// Creates type specific comparer. /// /// Type. /// Comparison Settings. Null by default. /// Parent comparer. Null by default. /// Instance of . public virtual IComparer GetObjectsComparer(ComparisonSettings settings = null, BaseComparer parentComparer = null) { return new Comparer(settings, parentComparer, this); } /// /// Creates type specific comparer. /// /// Type. /// Comparison Settings. Null by default. /// Parent comparer. Null by default. /// Instance of . public IComparer GetObjectsComparer(Type type, ComparisonSettings settings = null, BaseComparer parentComparer = null) { return new Comparer(settings, parentComparer, this); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Comparer~1.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Text; using ObjectsComparer.Utils; using ObjectsComparer.Attributes; namespace ObjectsComparer { /// /// Compares objects of type . /// public class Comparer : AbstractComparer { private readonly List _members; private readonly List _conditionalComparers; /// /// Initializes a new instance of the class. /// /// Comparison Settings. /// Parent Comparer. Is used to copy DefaultValueComparer and Overrides. Null by default. /// Factory to create comparers in case of some members of the objects will need it. public Comparer(ComparisonSettings settings = null, BaseComparer parentComparer = null, IComparersFactory factory = null) : base(settings, parentComparer, factory) { var properties = GetProperties(typeof(T), new List()); var fields = typeof(T).GetTypeInfo().GetFields().Where(f => f.IsPublic && !f.IsStatic && !f.GetCustomAttributes(true).Any(c=> c is IgnoreInComparisonAttribute)).ToList(); _members = properties.Union(fields.Cast()).ToList(); _conditionalComparers = new List { new MultidimensionalArraysComparer(Settings, this, Factory), new ExpandoObjectComparer(Settings, this, Factory), new DynamicObjectComparer(Settings, this, Factory), new CompilerGeneratedObjectComparer(Settings, this, Factory), new HashSetsComparer(Settings, this, Factory), new GenericEnumerablesComparer(Settings, this, Factory), new EnumerablesComparer(Settings, this, Factory), new TypesComparer(Settings, this, Factory) }; // Additional value comparers AddComparerOverride(new ToStringComparer()); AddComparerOverride(UriComparer.Instance); } /// /// Calculates list of differences between objects. /// /// Object 1. /// Object 2. /// List of differences between objects. public override IEnumerable CalculateDifferences(T obj1, T obj2) { return CalculateDifferences(obj1, obj2, null); } internal IEnumerable CalculateDifferences(T obj1, T obj2, MemberInfo memberInfo) { var comparer = memberInfo != null ? OverridesCollection.GetComparer(memberInfo) : OverridesCollection.GetComparer(typeof(T)); if (typeof(T).IsComparable() || comparer != null) { comparer = comparer ?? DefaultValueComparer; if (!comparer.Compare(obj1, obj2, Settings)) { yield return new Difference(string.Empty, comparer.ToString(obj1), comparer.ToString(obj2)); } yield break; } var conditionalComparer = _conditionalComparers.FirstOrDefault(c => c.IsMatch(typeof(T), obj1, obj2)); if (conditionalComparer != null) { foreach (var difference in conditionalComparer.CalculateDifferences(typeof(T), obj1, obj2)) { yield return difference; } if (conditionalComparer.IsStopComparison(typeof(T), obj1, obj2)) { yield break; } } if (obj1 == null || obj2 == null) { if (!DefaultValueComparer.Compare(obj1, obj2, Settings)) { yield return new Difference(string.Empty, DefaultValueComparer.ToString(obj1), DefaultValueComparer.ToString(obj2)); } yield break; } if (!Settings.RecursiveComparison) { yield break; } foreach (var member in _members) { if (member.GetCustomAttributes(true).Any(c => c is IgnoreInComparisonAttribute)) { continue; } var value1 = member.GetMemberValue(obj1); var value2 = member.GetMemberValue(obj2); var type = member.GetMemberType(); if (conditionalComparer != null && conditionalComparer.SkipMember(typeof(T), member)) { continue; } var valueComparer = DefaultValueComparer; var hasCustomComparer = false; var comparerOverride = OverridesCollection.GetComparer(member); if (comparerOverride != null) { valueComparer = comparerOverride; hasCustomComparer = true; } if (!hasCustomComparer && !type.IsComparable()) { var objectDataComparer = Factory.GetObjectsComparer(type, Settings, this); foreach (var failure in objectDataComparer.CalculateDifferences(type, value1, value2)) { yield return failure.InsertPath(member.Name); } continue; } if (!valueComparer.Compare(value1, value2, Settings)) { yield return new Difference(member.Name, valueComparer.ToString(value1), valueComparer.ToString(value2)); } } } private List GetProperties(Type type, List processedTypes) { var properties = type.GetTypeInfo().GetProperties().Where(p => p.CanRead && p.GetGetMethod(true).IsPublic && p.GetGetMethod(true).GetParameters().Length == 0 && !p.GetCustomAttributes(true).Any(c=> c is IgnoreInComparisonAttribute) && !p.GetGetMethod(true).IsStatic).ToList(); processedTypes.Add(type); if (type.GetTypeInfo().IsInterface) { foreach (var parrentInterface in type.GetTypeInfo().GetInterfaces()) { if (processedTypes.Contains(parrentInterface)) { continue; } properties = properties .Union(GetProperties(parrentInterface, processedTypes)) .Distinct() .ToList(); } } return properties; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ComparisonSettings.cs ================================================ using System; using System.Collections.Generic; namespace ObjectsComparer { /// /// Configuration for Objects Comparer. /// public class ComparisonSettings { /// /// If true, all members which are not primitive types, do not have custom comparison rule and /// do not implement  will be compared as separate objects using the same rules as current objects. True by default. /// public bool RecursiveComparison { get; set; } /// /// If true, empty and null values will be considered as equal values. False by default. /// public bool EmptyAndNullEnumerablesEqual { get; set; } /// /// If true and member does not exists, objects comparer will consider that this member is equal to default value of opposite member type. /// Applicable for dynamic types comparison only. False by default. /// public bool UseDefaultIfMemberNotExist { get; set; } private readonly Dictionary, object> _settings = new Dictionary, object>(); /// /// Initializes a new instance of the class. /// public ComparisonSettings() { RecursiveComparison = true; EmptyAndNullEnumerablesEqual = false; UseDefaultIfMemberNotExist = false; } /// /// Sets value of custom setting. Could be used to pass parameters to custom value comparers. /// /// Setting Type. /// Setting Value. /// Setting Key. public void SetCustomSetting(T value, string key = null) { var dictionaryKey = new Tuple(typeof(T), key); _settings[dictionaryKey] = value; } /// /// Gets value of custom setting. Could be used in custom value comparers. /// /// Setting Type. /// Setting Key. /// Setting Value. public T GetCustomSetting(string key = null) { var dictionaryKey = new Tuple(typeof(T), key); if (_settings.TryGetValue(dictionaryKey, out var value)) { return (T) value; } throw new KeyNotFoundException(); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/AbstractDynamicObjectsComprer.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal abstract class AbstractDynamicObjectsComprer: AbstractComparer, IComparerWithCondition { protected AbstractDynamicObjectsComprer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { var castedObject1 = (T)obj1; var castedObject2 = (T)obj2; var propertyKeys1 = GetProperties(castedObject1); var propertyKeys2 = GetProperties(castedObject2); var propertyKeys = propertyKeys1.Union(propertyKeys2); foreach (var propertyKey in propertyKeys) { var existsInObject1 = propertyKeys1.Contains(propertyKey); var existsInObject2 = propertyKeys2.Contains(propertyKey); object value1 = null; if (existsInObject1) { TryGetMemberValue(castedObject1, propertyKey, out value1); } object value2 = null; if (existsInObject2) { TryGetMemberValue(castedObject2, propertyKey, out value2); } var propertyType = (value1 ?? value2)?.GetType() ?? typeof(object); var customComparer = OverridesCollection.GetComparer(propertyType) ?? OverridesCollection.GetComparer(propertyKey); var valueComparer = customComparer ?? DefaultValueComparer; if (Settings.UseDefaultIfMemberNotExist) { if (!existsInObject1) { value1 = propertyType.GetDefaultValue(); } if (!existsInObject2) { value2 = propertyType.GetDefaultValue(); } } if (!Settings.UseDefaultIfMemberNotExist) { if (!existsInObject1) { yield return new Difference(propertyKey, string.Empty, valueComparer.ToString(value2), DifferenceTypes.MissedMemberInFirstObject); continue; } if (!existsInObject2) { yield return new Difference(propertyKey, valueComparer.ToString(value1), string.Empty, DifferenceTypes.MissedMemberInSecondObject); continue; } } if (value1 != null && value2 != null && value1.GetType() != value2.GetType()) { var valueComparer2 = OverridesCollection.GetComparer(value2.GetType()) ?? OverridesCollection.GetComparer(propertyKey) ?? DefaultValueComparer; yield return new Difference(propertyKey, valueComparer.ToString(value1), valueComparer2.ToString(value2), DifferenceTypes.TypeMismatch); continue; } //null cannot be casted to ValueType if (value1 == null && value2 != null && value2.GetType().GetTypeInfo().IsValueType || value2 == null && value1 != null && value1.GetType().GetTypeInfo().IsValueType) { var valueComparer2 = value2 != null ? OverridesCollection.GetComparer(value2.GetType()) ?? OverridesCollection.GetComparer(propertyKey) ?? DefaultValueComparer : DefaultValueComparer; yield return new Difference(propertyKey, valueComparer.ToString(value1), valueComparer2.ToString(value2), DifferenceTypes.TypeMismatch); continue; } if (customComparer != null) { if (!customComparer.Compare(value1, value2, Settings)) { yield return new Difference(propertyKey, customComparer.ToString(value1), customComparer.ToString(value2)); } continue; } var comparer = Factory.GetObjectsComparer(propertyType, Settings, this); foreach (var failure in comparer.CalculateDifferences(propertyType, value1, value2)) { yield return failure.InsertPath(propertyKey); } } } public abstract bool IsMatch(Type type, object obj1, object obj2); public abstract bool IsStopComparison(Type type, object obj1, object obj2); public abstract bool SkipMember(Type type, MemberInfo member); protected abstract IList GetProperties(T obj); protected abstract bool TryGetMemberValue(T obj, string propertyName, out object value); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/AbstractEnumerablesComparer.cs ================================================ using System; using System.Collections.Generic; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal abstract class AbstractEnumerablesComparer: AbstractComparer, IComparerWithCondition { protected AbstractEnumerablesComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public bool IsStopComparison(Type type, object obj1, object obj2) { return Settings.EmptyAndNullEnumerablesEqual && (obj1 == null || obj2 == null); } public virtual bool SkipMember(Type type, MemberInfo member) { if (type.InheritsFrom(typeof(Array))) { if (member.Name == "LongLength") { return true; } } if (type.InheritsFrom(typeof(List<>))) { if (member.Name == PropertyHelper.GetMemberInfo(() => new List().Capacity).Name) { return true; } } return false; } public abstract override IEnumerable CalculateDifferences(Type type, object obj1, object obj2); public abstract bool IsMatch(Type type, object obj1, object obj2); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/CompilerGeneratedObjectComparer.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; namespace ObjectsComparer { internal class CompilerGeneratedObjectComparer : AbstractDynamicObjectsComprer { public CompilerGeneratedObjectComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override bool IsMatch(Type type, object obj1, object obj2) { return (obj1 != null || obj2 != null) && (obj1 == null || obj1.GetType().GetTypeInfo().GetCustomAttribute(typeof(CompilerGeneratedAttribute)) != null) && (obj2 == null || obj2.GetType().GetTypeInfo().GetCustomAttribute(typeof(CompilerGeneratedAttribute)) != null); } public override bool IsStopComparison(Type type, object obj1, object obj2) { return true; } public override bool SkipMember(Type type, MemberInfo member) { return false; } protected override IList GetProperties(object obj) { return obj?.GetType().GetTypeInfo().GetMembers() .Where(memberInfo => memberInfo is PropertyInfo) .Select(memberInfo => memberInfo.Name) .Distinct() .ToList() ?? new List(); } protected override bool TryGetMemberValue(object obj, string propertyName, out object value) { value = null; if (obj == null) { return false; } var propertyInfo = obj.GetType().GetTypeInfo().GetProperty(propertyName); if (propertyInfo == null) { return false; } value = propertyInfo.GetValue(obj); return true; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/DynamicObjectComparer.cs ================================================ using System; using System.Collections.Generic; using System.Dynamic; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class DynamicObjectComparer : AbstractDynamicObjectsComprer { private class FakeGetMemberBinder : GetMemberBinder { public FakeGetMemberBinder(string name, bool ignoreCase) : base(name, ignoreCase) { } public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion) { throw new NotSupportedException(); } } public DynamicObjectComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override bool IsMatch(Type type, object obj1, object obj2) { return type.InheritsFrom(typeof(DynamicObject)) || (obj1 != null && obj2 != null && type == typeof(object) && obj1.GetType().InheritsFrom(typeof(DynamicObject)) && obj2.GetType().InheritsFrom(typeof(DynamicObject))); } public override bool IsStopComparison(Type type, object obj1, object obj2) { return obj1 == null || obj2 == null; } public override bool SkipMember(Type type, MemberInfo member) { return false; } protected override IList GetProperties(DynamicObject obj) { return obj?.GetDynamicMemberNames().ToList() ?? new List(); } protected override bool TryGetMemberValue(DynamicObject obj, string propertyName, out object value) { if (obj == null) { value = null; return false; } var getBinder = new FakeGetMemberBinder(propertyName, false); return obj.TryGetMember(getBinder, out value); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/EnumerablesComparer.cs ================================================ using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class EnumerablesComparer : AbstractComparer, IComparerWithCondition { public EnumerablesComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (!Settings.EmptyAndNullEnumerablesEqual && (obj1 == null || obj2 == null) && obj1 != obj2) { yield return new Difference("[]", obj1?.ToString() ?? string.Empty, obj2?.ToString() ?? string.Empty); yield break; } obj1 = obj1 ?? Enumerable.Empty(); obj2 = obj2 ?? Enumerable.Empty(); if (!type.InheritsFrom(typeof(IEnumerable))) { throw new ArgumentException(nameof(type)); } if (!obj1.GetType().InheritsFrom(typeof(IEnumerable))) { throw new ArgumentException(nameof(obj1)); } if (!obj2.GetType().InheritsFrom(typeof(IEnumerable))) { throw new ArgumentException(nameof(obj2)); } var array1 = ((IEnumerable)obj1).Cast().ToArray(); var array2 = ((IEnumerable)obj2).Cast().ToArray(); if (array1.Length != array2.Length) { yield return new Difference("", array1.Length.ToString(), array2.Length.ToString(), DifferenceTypes.NumberOfElementsMismatch); yield break; } //ToDo Extract type for (var i = 0; i < array2.Length; i++) { if (array1[i] == null && array2[i] == null) { continue; } var valueComparer1 = array1[i] != null ? OverridesCollection.GetComparer(array1[i].GetType()) ?? DefaultValueComparer : DefaultValueComparer; var valueComparer2 = array2[i] != null ? OverridesCollection.GetComparer(array2[i].GetType()) ?? DefaultValueComparer : DefaultValueComparer; if (array1[i] == null) { yield return new Difference($"[{i}]", string.Empty, valueComparer2.ToString(array2[i])); continue; } if (array2[i] == null) { yield return new Difference($"[{i}]", valueComparer1.ToString(array1[i]), string.Empty); continue; } if (array1[i].GetType() != array2[i].GetType()) { yield return new Difference($"[{i}]", valueComparer1.ToString(array1[i]), valueComparer2.ToString(array2[i]), DifferenceTypes.TypeMismatch); continue; } var comparer = Factory.GetObjectsComparer(array1[i].GetType(), Settings, this); foreach (var failure in comparer.CalculateDifferences(array1[i].GetType(), array1[i], array2[i])) { yield return failure.InsertPath($"[{i}]"); } } } public bool IsMatch(Type type, object obj1, object obj2) { return type.InheritsFrom(typeof(IEnumerable)) && !type.InheritsFrom(typeof(IEnumerable<>)); } public bool IsStopComparison(Type type, object obj1, object obj2) { return Settings.EmptyAndNullEnumerablesEqual && obj1 == null || obj2 == null; } public bool SkipMember(Type type, MemberInfo member) { return false; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/EnumerablesComparer~1.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class EnumerablesComparer : AbstractComparer { private readonly IComparer _comparer; public EnumerablesComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) :base(settings, parentComparer, factory) { _comparer = Factory.GetObjectsComparer(Settings, this); } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (!type.InheritsFrom(typeof(IEnumerable<>))) { throw new ArgumentException("Invalid type"); } if (!Settings.EmptyAndNullEnumerablesEqual && (obj1 == null || obj2 == null) && obj1 != obj2) { yield break; } obj1 = obj1 ?? Enumerable.Empty(); obj2 = obj2 ?? Enumerable.Empty(); if (!obj1.GetType().InheritsFrom(typeof(IEnumerable))) { throw new ArgumentException(nameof(obj1)); } if (!obj2.GetType().InheritsFrom(typeof(IEnumerable))) { throw new ArgumentException(nameof(obj2)); } var list1 = ((IEnumerable)obj1).ToList(); var list2 = ((IEnumerable)obj2).ToList(); if (list1.Count != list2.Count) { if (!type.GetTypeInfo().IsArray) { yield return new Difference("", list1.Count.ToString(), list2.Count.ToString(), DifferenceTypes.NumberOfElementsMismatch); } yield break; } for (var i = 0; i < list2.Count; i++) { foreach (var failure in _comparer.CalculateDifferences(list1[i], list2[i])) { yield return failure.InsertPath($"[{i}]"); } } } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/ExpandoObjectComparer.cs ================================================ using System; using System.Collections.Generic; using System.Dynamic; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class ExpandoObjectComparer : AbstractDynamicObjectsComprer { public ExpandoObjectComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override bool IsMatch(Type type, object obj1, object obj2) { return type.InheritsFrom(typeof(ExpandoObject)) || (obj1 != null && obj2 != null && type == typeof(object) && obj1.GetType().InheritsFrom(typeof(ExpandoObject)) && obj2.GetType().InheritsFrom(typeof(ExpandoObject))); } public override bool IsStopComparison(Type type, object obj1, object obj2) { return obj1 == null || obj2 == null; } public override bool SkipMember(Type type, MemberInfo member) => false; protected override IList GetProperties(ExpandoObject obj) { return ((IDictionary) obj)?.Keys.ToList() ?? new List(); } protected override bool TryGetMemberValue(ExpandoObject obj, string propertyName, out object value) { if (obj != null) { return ((IDictionary) obj).TryGetValue(propertyName, out value); } value = null; return false; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/GenericEnumerablesComparer.cs ================================================ using System; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class GenericEnumerablesComparer : AbstractEnumerablesComparer { public GenericEnumerablesComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (obj1 == null && obj2 == null) { yield break; } var typeInfo = (obj1 ?? obj2).GetType().GetTypeInfo(); Type elementType; if (typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == typeof(IEnumerable<>)) { elementType = typeInfo.GetElementType(); } else { elementType = typeInfo.GetInterfaces() .Where( i => i.GetTypeInfo().IsGenericType && i.GetTypeInfo().GetGenericTypeDefinition() == typeof(IEnumerable<>)) .Select(i => i.GetTypeInfo().GetGenericArguments()[0]) .First(); } var enumerablesComparerType = typeof(EnumerablesComparer<>).MakeGenericType(elementType); var comparer = (IComparer)Activator.CreateInstance(enumerablesComparerType, Settings, this, Factory); foreach (var difference in comparer.CalculateDifferences(type, obj1, obj2)) { yield return difference; } } public override bool IsMatch(Type type, object obj1, object obj2) { return type.InheritsFrom(typeof(IEnumerable<>)); } public override bool SkipMember(Type type, MemberInfo member) { if (base.SkipMember(type, member)) { return true; } if (type.InheritsFrom(typeof(ICollection<>)) && member.Name == PropertyHelper.GetMemberInfo(() => new Collection().Count).Name) { return true; } if (!type.InheritsFrom(typeof(IDictionary<,>))) { return false; } return member.Name == PropertyHelper.GetMemberInfo(() => new Dictionary().Values).Name || member.Name == PropertyHelper.GetMemberInfo(() => new Dictionary().Keys).Name; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/HashSetsComparer.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class HashSetsComparer : AbstractEnumerablesComparer { public HashSetsComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (obj1 == null && obj2 == null) { yield break; } var typeInfo = (obj1 ?? obj2).GetType().GetTypeInfo(); Type elementType = typeInfo.GetInterfaces() .Where( i => i.GetTypeInfo().IsGenericType && i.GetTypeInfo().GetGenericTypeDefinition() == typeof(ISet<>)) .Select(i => i.GetTypeInfo().GetGenericArguments()[0]) .First(); var enumerablesComparerType = typeof(HashSetsComparer<>).MakeGenericType(elementType); var comparer = (IComparer)Activator.CreateInstance(enumerablesComparerType, Settings, this, Factory); foreach (var difference in comparer.CalculateDifferences(type, obj1, obj2)) { yield return difference; } } public override bool IsMatch(Type type, object obj1, object obj2) { return type.InheritsFrom(typeof(HashSet<>)); } public override bool SkipMember(Type type, MemberInfo member) { return base.SkipMember(type, member) || member.Name == PropertyHelper.GetMemberInfo(() => new HashSet().Comparer).Name || member.Name == PropertyHelper.GetMemberInfo(() => new HashSet().Count).Name; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/HashSetsComparer~1.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class HashSetsComparer : AbstractComparer { public HashSetsComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) :base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (!type.InheritsFrom(typeof(HashSet<>))) { throw new ArgumentException("Invalid type"); } if (!Settings.EmptyAndNullEnumerablesEqual && (obj1 == null || obj2 == null) && obj1 != obj2) { yield break; } obj1 = obj1 ?? new HashSet(); obj2 = obj2 ?? new HashSet(); if (!obj1.GetType().InheritsFrom(typeof(HashSet))) { throw new ArgumentException(nameof(obj1)); } if (!obj2.GetType().InheritsFrom(typeof(HashSet))) { throw new ArgumentException(nameof(obj2)); } var hashSet1 = ((IEnumerable)obj1).ToList(); var hashSet2 = ((IEnumerable)obj2).ToList(); var valueComparer = OverridesCollection.GetComparer(typeof(T)) ?? DefaultValueComparer; foreach (var element in hashSet1) { if (!hashSet2.Contains(element)) { yield return new Difference("", valueComparer.ToString(element), string.Empty, DifferenceTypes.MissedElementInSecondObject); } } foreach (var element in hashSet2) { if (!hashSet1.Contains(element)) { yield return new Difference("", string.Empty, valueComparer.ToString(element), DifferenceTypes.MissedElementInFirstObject); } } } public bool IsMatch(Type type, object obj1, object obj2) { return type.InheritsFrom(typeof(HashSet<>)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/IComparerWithCondition.cs ================================================ using System; using System.Reflection; namespace ObjectsComparer { internal interface IComparerWithCondition: IComparer { bool IsMatch(Type type, object obj1, object obj2); bool IsStopComparison(Type type, object obj1, object obj2); bool SkipMember(Type type, MemberInfo member); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/MultidimensionalArrayComparer~1.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class MultidimensionalArrayComparer : AbstractComparer { private readonly IComparer _comparer; public MultidimensionalArrayComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { _comparer = Factory.GetObjectsComparer(Settings, this); } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (!type.InheritsFrom(typeof(Array))) { throw new ArgumentException("Invalid type"); } if (!Settings.EmptyAndNullEnumerablesEqual && (obj1 == null || obj2 == null) && obj1 != obj2) { yield break; } if (obj1 != null && !obj1.GetType().InheritsFrom(typeof(Array))) { throw new ArgumentException(nameof(obj1)); } if (obj2 != null && !obj2.GetType().InheritsFrom(typeof(Array))) { throw new ArgumentException(nameof(obj2)); } var array1 = (Array)obj1 ?? Array.CreateInstance(typeof(T), new int[type.GetArrayRank()]); var array2 = (Array)obj2 ?? Array.CreateInstance(typeof(T), new int[type.GetArrayRank()]); if (array1.Rank != array2.Rank) { yield return new Difference("Rank", array1.Rank.ToString(), array2.Rank.ToString()); yield break; } var dimensionsFailure = false; for (var i = 0; i < array1.Rank; i++) { var length1 = array1.GetLength(i); var length2 = array2.GetLength(i); // ReSharper disable once InvertIf if (length1 != length2) { dimensionsFailure = true; yield return new Difference($"Dimension{i}", length1.ToString(), length2.ToString()); } } if (dimensionsFailure) { yield break; } for (var i = 0; i < array1.Length; i++) { var indecies = IndexToCoordinates(array1, i); foreach (var failure in _comparer.CalculateDifferences((T)array1.GetValue(indecies), (T)array2.GetValue(indecies))) { yield return failure.InsertPath($"[{string.Join(",", indecies)}]"); } } } private static int[] IndexToCoordinates(Array arr, int i) { var dims = Enumerable.Range(0, arr.Rank) .Select(arr.GetLength) .ToArray(); return dims.Select((d, n) => i / dims.Take(n).Aggregate(1, (i1, i2) => i1 * i2) % d).ToArray(); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/MultidimensionalArraysComparer.cs ================================================ using System; using System.Collections.Generic; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class MultidimensionalArraysComparer : AbstractEnumerablesComparer { public MultidimensionalArraysComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (obj1 == null && obj2 == null) { yield break; } var typeInfo = (obj1 ?? obj2).GetType().GetTypeInfo(); var enumerablesComparerType = typeof(MultidimensionalArrayComparer<>).MakeGenericType(typeInfo.GetElementType()); var comparer = (IComparer)Activator.CreateInstance(enumerablesComparerType, Settings, this, Factory); foreach (var difference in comparer.CalculateDifferences(type, obj1, obj2)) { yield return difference; } } public override bool IsMatch(Type type, object obj1, object obj2) { return type.GetTypeInfo().IsArray && type.GetTypeInfo().GetArrayRank() > 1; } public override bool SkipMember(Type type, MemberInfo member) { if (base.SkipMember(type, member)) { return true; } if (!type.IsArray) { return false; } Array array = new int[0]; return member.Name == PropertyHelper.GetMemberInfo(() => array.Length).Name; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/CustomComparers/TypesComparer.cs ================================================ using System; using System.Collections.Generic; using System.Reflection; using ObjectsComparer.Utils; namespace ObjectsComparer { internal class TypesComparer : AbstractComparer, IComparerWithCondition { public TypesComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(Type type, object obj1, object obj2) { if (obj1 == null && obj2 == null) { yield break; } if (obj1?.GetType().InheritsFrom(typeof(Type)) == false) { throw new ArgumentException(nameof(obj1)); } if (obj2?.GetType().InheritsFrom(typeof(Type)) == false) { throw new ArgumentException(nameof(obj2)); } var type1Str = obj1?.ToString(); var type2Str = obj2?.ToString(); if (type1Str != type2Str) { yield return new Difference(string.Empty, type1Str, type2Str); } } public bool IsMatch(Type type, object obj1, object obj2) { return type.InheritsFrom(typeof(Type)); } public bool IsStopComparison(Type type, object obj1, object obj2) => true; public bool SkipMember(Type type, MemberInfo member) => true; } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Difference.cs ================================================ namespace ObjectsComparer { /// /// Represents difference in one member between objects. /// public class Difference { /// /// Path to the member. /// public string MemberPath { get; } /// /// Value in the first object, converted to string. /// public string Value1 { get; } /// /// Value in the second object, converted to string. /// public string Value2 { get; } /// /// Type of the difference. /// public DifferenceTypes DifferenceType { get; } /// /// Initializes a new instance of the class. /// /// Member Path. /// Value of the first object, converted to string. /// Value of the second object, converted to string. /// Type of the difference. public Difference(string memberPath, string value1, string value2, DifferenceTypes differenceType = DifferenceTypes.ValueMismatch) { MemberPath = memberPath; Value1 = value1; Value2 = value2; DifferenceType = differenceType; } /// /// Combines difference with path of the root element. /// /// Root element path. /// Difference with combined . public Difference InsertPath(string path) { var newPath = string.IsNullOrWhiteSpace(MemberPath) || MemberPath.StartsWith("[") ? path + MemberPath : path + "." + MemberPath; return new Difference( newPath, Value1, Value2, DifferenceType); } /// Returns a string that represents the current object. /// A string that represents the current object. public override string ToString() { return $"Difference: DifferenceType={DifferenceType}, MemberPath='{MemberPath}', Value1='{Value1}', Value2='{Value2}'."; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/DifferenceTypes.cs ================================================ using System.Collections; namespace ObjectsComparer { /// /// Specifies types of the differences between object members. /// public enum DifferenceTypes { /// /// Value of the member in first and second objects are not equal. /// ValueMismatch, /// /// Type of the member in first and second objects are not equal. /// TypeMismatch, /// /// Member does not exist in the first object. /// MissedMemberInFirstObject, /// /// Member does not exist in the second object. /// MissedMemberInSecondObject, /// /// First object does not contain element. /// MissedElementInFirstObject, /// /// Second object does not contain element. /// MissedElementInSecondObject, /// /// s have different number of elements. /// NumberOfElementsMismatch } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Exceptions/AmbiguousComparerOverrideResolutionException.cs ================================================ using System; using System.Reflection; namespace ObjectsComparer.Exceptions { /// /// Represents errors that occur when Objects Comparer has more than one comparer override which could be used to compare member. /// public class AmbiguousComparerOverrideResolutionException: Exception { /// /// Name of the Member that was a cause of exception /// public string MemberName { get; } /// /// MemberInfo of the Member that was a cause of exception /// public MemberInfo MemberInfo { get; } /// /// Type that was a cause of exception /// public Type Type { get; } internal AmbiguousComparerOverrideResolutionException(MemberInfo memberInfo) : base($"Unable to resolve comparer for member {memberInfo.MemberType}. More than one value comparer meet criteria for this member.") { MemberInfo = memberInfo; MemberName = memberInfo.Name; } internal AmbiguousComparerOverrideResolutionException(string memberName) : base($"Unable to resolve comparer for member {memberName}. More than one value comparer meet criteria for this member.") { MemberName = memberName; } internal AmbiguousComparerOverrideResolutionException(Type type) : base($"Unable to resolve comparer for type {type.GetTypeInfo().FullName}. More than one value comparer meet criteria for this type.") { Type = type; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Exceptions/ValueComparerExistsException.cs ================================================ using System; using System.Reflection; namespace ObjectsComparer.Exceptions { /// /// Represents errors that occur when comparer for Member has already been added. /// public class ValueComparerExistsException: Exception { /// /// MemberInfo of the Member that was a cause of exception /// public MemberInfo MemberInfo { get; } internal ValueComparerExistsException(MemberInfo memberInfo) : base($"Comparer override for member {memberInfo.MemberType} has already been added.") { MemberInfo = memberInfo; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/IBaseComparer.cs ================================================ using System; using System.Linq.Expressions; using System.Reflection; namespace ObjectsComparer { /// /// Defines properties and methods to configure comparer. /// public interface IBaseComparer { /// /// Default /// IValueComparer DefaultValueComparer { get; } /// /// Comparison Settings. /// ComparisonSettings Settings { get; } /// /// Sets . /// /// Value Comparer. void SetDefaultComparer(IValueComparer valueComparer); /// /// Adds Comparer Override by Member. /// /// Type of the member. /// Lambda to get member. /// Value Comparer. void AddComparerOverride(Expression> memberLambda, IValueComparer valueComparer); /// /// Adds Comparer Override by Member. /// /// Member Info. /// Value Comparer. void AddComparerOverride(MemberInfo memberInfo, IValueComparer valueComparer); /// /// Adds Comparer Override by Type. /// /// Type. /// Value Comparer. /// Value Comparer will be used only if filter(memberInfo) == true. Null by default. void AddComparerOverride(Type type, IValueComparer valueComparer, Func filter = null); /// /// Adds Comparer Override by Type. /// /// Type. /// Value Comparer. /// Value Comparer will be used only if filter(memberInfo) == true. Null by default. void AddComparerOverride(IValueComparer valueComparer, Func filter = null); /// /// Adds Comparer Override by Member. /// /// Type of the member. /// Lambda to get member. /// Function to compare objects. /// Function to convert objects to string. void AddComparerOverride( Expression> memberLambda, Func compareFunction, Func toStringFunction); /// /// Adds Comparer Override by Member. /// /// Type of the member. /// Lambda to get member. /// Function to compare objects. void AddComparerOverride( Expression> memberLambda, Func compareFunction); /// /// Adds Comparer Override by Member name. /// /// Member Name. /// Value Comparer. /// Value Comparer will be used only if filter(memberInfo) == true. Null by default. void AddComparerOverride(string memberName, IValueComparer valueComparer, Func filter = null); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/IComparer.cs ================================================ using System; using System.Collections.Generic; namespace ObjectsComparer { /// /// Defines methods to compare complex objects. /// public interface IComparer : IBaseComparer { /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences. /// True if objects are equal, otherwise false. bool Compare(Type type, object obj1, object obj2, out IEnumerable differences); /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences. /// True if objects are equal, otherwise false. bool Compare(T obj1, T obj2, out IEnumerable differences); /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// True if objects are equal, otherwise false. bool Compare(Type type, object obj1, object obj2); /// /// Compares objects. /// /// Type. /// Object 1. /// Object 2. /// True if objects are equal, otherwise false. bool Compare(T obj1, T obj2); /// /// Calculates list of differences between objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences between objects. IEnumerable CalculateDifferences(Type type, object obj1, object obj2); /// /// Calculates list of differences between objects. /// /// Type. /// Object 1. /// Object 2. /// List of differences between objects. IEnumerable CalculateDifferences(T obj1, T obj2); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/IComparersFactory.cs ================================================ using System; namespace ObjectsComparer { /// /// Defines methods to create type specific comparers. /// public interface IComparersFactory { /// /// Creates type specific comparer. /// /// Type. /// Comparison Settings. Null by default. /// Parent comparer. Null by default. /// Instance of . IComparer GetObjectsComparer(ComparisonSettings settings = null, BaseComparer parentComparer = null); /// /// Creates type specific comparer. /// /// Type. /// Comparison Settings. Null by default. /// Parent comparer. Null by default. /// Instance of . IComparer GetObjectsComparer(Type type, ComparisonSettings settings = null, BaseComparer parentComparer = null); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/IComparer~1.cs ================================================ using System.Collections.Generic; namespace ObjectsComparer { /// /// Defines methods to compare complex objects of particular type. /// public interface IComparer: IBaseComparer { /// /// Compares objects. /// /// Object 1. /// Object 2. /// List of differences. /// True if objects are equal, otherwise false. bool Compare(T obj1, T obj2, out IEnumerable differences); /// /// Compares objects. /// /// Object 1. /// Object 2. /// True if objects are equal, otherwise false. bool Compare(T obj1, T obj2); /// /// Calculates list of differences between objects. /// /// Object 1. /// Object 2. /// List of differences between objects. IEnumerable CalculateDifferences(T obj1, T obj2); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/LICENSE ================================================ MIT License Copyright (c) 2019 Valerii Tereshchenko Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: ObjectsComparer/ObjectsComparer/ObjectsComparer.csproj ================================================  netstandard2.1;netstandard2.0;netstandard1.6;net45 1.4.1 Valerii Tereshchenko Objects Data Comparer Framework provides mechanism to compare classes, allows override comparison rules for specific properties and types. Copyright © Valerii Tereshchenko 2019 https://github.com/ValeraT1982/ObjectsComparer https://github.com/ValeraT1982/ObjectsComparer/blob/master/ObjectsDataComparer.png?raw=true https://github.com/ValeraT1982/ObjectsComparer C#, compare, class, reflection, object, comparison false LICENSE ================================================ FILE: ObjectsComparer/ObjectsComparer/ObjectsComparer.csproj.DotSettings ================================================  True True ================================================ FILE: ObjectsComparer/ObjectsComparer/Properties/AssemblyInfo.cs ================================================ using System.Runtime.CompilerServices; [assembly: InternalsVisibleTo("ObjectsComparer.Tests")] ================================================ FILE: ObjectsComparer/ObjectsComparer/Utils/MemberInfoExtensions.cs ================================================ using System; using System.Linq.Expressions; using System.Reflection; namespace ObjectsComparer.Utils { internal static class MemberInfoExtensions { public static Type GetMemberType(this MemberInfo memberInfo) { var propertyInfo = memberInfo as PropertyInfo; if (propertyInfo != null) { return propertyInfo.PropertyType; } var fieldInfo = memberInfo as FieldInfo; if (fieldInfo != null) { return fieldInfo.FieldType; } throw new Exception("Unsupported Type"); } public static object GetMemberValue(this MemberInfo memberInfo, object obj) { var propertyInfo = memberInfo as PropertyInfo; if (propertyInfo != null) { try { return propertyInfo.GetValue(obj); } catch { return $"Unable to get value of property {memberInfo.Name} of type {memberInfo.DeclaringType}"; } } var fieldInfo = memberInfo as FieldInfo; if (fieldInfo != null) { return fieldInfo.GetValue(obj); } throw new Exception("Unsupported Type"); } public static string GetMethodName(Expression> expression) { return ((MethodCallExpression)expression.Body).Method.Name; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Utils/PropertyHelper.cs ================================================ using System; using System.Linq.Expressions; using System.Reflection; namespace ObjectsComparer.Utils { internal class PropertyHelper { public static MemberInfo GetMemberInfo(Expression> memberLambda) { MemberExpression exp; //this line is necessary, because sometimes the expression comes in as Convert(originalexpression) switch (memberLambda.Body) { case UnaryExpression body: var unExp = body; if (unExp.Operand is MemberExpression operand) { exp = operand; } else { throw new ArgumentException(); } break; case MemberExpression _: exp = (MemberExpression)memberLambda.Body; break; default: throw new ArgumentException(); } return exp.Member; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/Utils/TypeExtensions.cs ================================================ using System; using System.Linq; using System.Reflection; namespace ObjectsComparer.Utils { internal static class TypeExtensions { public static bool InheritsFrom(this Type t1, Type t2) { if (null == t1 || null == t2) { return false; } if (t1 == t2) { return true; } if (t1.GetTypeInfo().IsGenericType && t1.GetTypeInfo().GetGenericTypeDefinition() == t2) { return true; } if (t1.GetTypeInfo().GetInterfaces().Any(i => i.GetTypeInfo().IsGenericType && i.GetGenericTypeDefinition() == t2 || i == t2)) { return true; } return t1.GetTypeInfo().BaseType != null && InheritsFrom(t1.GetTypeInfo().BaseType, t2); } public static bool IsComparable(this Type type) { return type.GetTypeInfo().IsPrimitive || type.GetTypeInfo().IsEnum || type.InheritsFrom(typeof(IComparable)) || type.InheritsFrom(typeof(IComparable<>)); } public static object GetDefaultValue(this Type t) { if (t.GetTypeInfo().IsValueType && Nullable.GetUnderlyingType(t) == null) { return Activator.CreateInstance(t); } return null; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/AbstractValueComparer.cs ================================================ namespace ObjectsComparer { /// /// Implementation of which provides simplest implementation of method. /// public abstract class AbstractValueComparer: IValueComparer { public abstract bool Compare(object obj1, object obj2, ComparisonSettings settings); public virtual string ToString(object value) { return value?.ToString(); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/AbstractValueComparer~1.cs ================================================ namespace ObjectsComparer { /// /// Implementation of which provides simplest implementation of method and /// method to call . /// /// Type of the objects. public abstract class AbstractValueComparer: AbstractValueComparer, IValueComparer { /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public abstract bool Compare(T obj1, T obj2, ComparisonSettings settings); /// /// Converts values of comparing objects to . /// /// Object to convert. /// A string that represents . public virtual string ToString(T value) { return base.ToString(value); } /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public override bool Compare(object obj1, object obj2, ComparisonSettings settings) { return Compare((T) obj1, (T) obj2, settings); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/DefaultValueComparer.cs ================================================ namespace ObjectsComparer { /// /// Default implementation of /// public class DefaultValueComparer: IValueComparer { private static volatile IValueComparer _instance; /// /// Static instance. /// public static IValueComparer Instance { get { if (_instance != null) { return _instance; } lock (SyncRoot) { if (_instance == null) { _instance = new DefaultValueComparer(); } } return _instance; } } private static readonly object SyncRoot = new object(); /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public bool Compare(object obj1, object obj2, ComparisonSettings settings) { if (obj1 == null || obj2 == null) { return obj1 == obj2; } return obj1.Equals(obj2); } /// /// Converts values of comparing objects to . /// /// Object to convert. /// A string that represents . public string ToString(object value) { return value?.ToString() ?? string.Empty; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/DefaultValueValueComparer.cs ================================================ namespace ObjectsComparer { /// /// Allows to consider provided value and default value of type as equal values. /// /// Type of the objects. public class DefaultValueValueComparer : IValueComparer { private readonly T _defaultValue; private readonly T _typeDefaultValue; private readonly IValueComparer _valueComparer; /// /// Initializes a new instance of the class. /// /// Default value. /// Instance of which is used when values are not defaults. public DefaultValueValueComparer(T defaultValue, IValueComparer valueComparer) { _defaultValue = defaultValue; _valueComparer = valueComparer; _typeDefaultValue = default(T); } /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public bool Compare(object obj1, object obj2, ComparisonSettings settings) { var isObj1Default = obj1?.Equals(_defaultValue) != false || obj1.Equals(_typeDefaultValue); var isObj2Default = obj2?.Equals(_defaultValue) != false || obj2.Equals(_typeDefaultValue); return isObj1Default && isObj2Default || _valueComparer.Compare(obj1, obj2, settings); } /// /// Converts values of comparing objects to . /// /// Object to convert. /// A string that represents . public string ToString(object value) { return value?.Equals(_typeDefaultValue) != false ? _valueComparer.ToString(_defaultValue) : _valueComparer.ToString(value); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/DoNotCompareValueComparer.cs ================================================ namespace ObjectsComparer { /// /// Allows to ignore comparison. Considers all values as equal. /// public class DoNotCompareValueComparer : IValueComparer { private static volatile IValueComparer _instance; /// /// Static instance. /// public static IValueComparer Instance { get { if (_instance != null) { return _instance; } lock (SyncRoot) { if (_instance == null) { _instance = new DoNotCompareValueComparer(); } } return _instance; } } private static readonly object SyncRoot = new object(); private DoNotCompareValueComparer() { } /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public bool Compare(object obj1, object obj2, ComparisonSettings settings) { return true; } /// /// Converts values of comparing objects to . /// /// Object to convert. /// A string that represents . public string ToString(object value) { return string.Empty; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/DynamicValueComparer.cs ================================================ using System; using System.Reflection; namespace ObjectsComparer { /// /// Allows to provide comparison rule as a function. /// /// Type of the objects. public class DynamicValueComparer: IValueComparer { private readonly Func _compareFunction; private readonly Func _toStringFunction; /// /// Initializes a new instance of the class. /// /// Function to compare objects of type . public DynamicValueComparer(Func compareFunction): this(compareFunction, obj => obj?.ToString() ?? string.Empty) { } /// /// Initializes a new instance of the class. /// /// Function to compare objects of type . /// Function to convert objects of type to . public DynamicValueComparer(Func compareFunction, Func toStringFunction) { _compareFunction = compareFunction ?? throw new ArgumentNullException(nameof(compareFunction)); _toStringFunction = toStringFunction ?? throw new ArgumentNullException(nameof(toStringFunction)); } /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public bool Compare(object obj1, object obj2, ComparisonSettings settings) { IsArgumentException(obj1, nameof(obj1)); IsArgumentException(obj2, nameof(obj2)); return _compareFunction((T)obj1, (T)obj2, settings); } /// /// Converts values of comparing objects to . /// /// Object to convert. /// A string that represents . public string ToString(object value) { IsArgumentException(value, nameof(value)); return _toStringFunction((T)value); } // ReSharper disable once UnusedParameter.Local private void IsArgumentException(object obj, string argumentName) { var t = typeof(T).GetTypeInfo(); if (!(obj is T) && !((t.IsClass || Nullable.GetUnderlyingType(typeof(T)) != null) && obj == null)) { throw new ArgumentException(argumentName); } } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/IValueComparer.cs ================================================ namespace ObjectsComparer { /// /// Defines a generalized comparison method to compare 2 objects. /// public interface IValueComparer { /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. bool Compare(object obj1, object obj2, ComparisonSettings settings); /// /// Converts values of comparing objects to . /// /// Object to convert. /// A string that represents . string ToString(object value); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/IValueComparer~1.cs ================================================ namespace ObjectsComparer { /// /// Defines a generalized type-specific comparison method to compare 2 objects. /// /// Type of the objects. public interface IValueComparer: IValueComparer { /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. bool Compare(T obj1, T obj2, ComparisonSettings settings); /// /// Converts values of comparing objects to . /// /// Object to convert. /// A string that represents . string ToString(T value); } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/IgnoreCaseStringsValueComparer.cs ================================================ using System; namespace ObjectsComparer { /// /// Allows to compare string ignoring case. /// public class IgnoreCaseStringsValueComparer : AbstractValueComparer { private static volatile IValueComparer _instance; /// /// Static instance. /// public static IValueComparer Instance { get { if (_instance != null) { return _instance; } lock (SyncRoot) { if (_instance == null) { _instance = new IgnoreCaseStringsValueComparer(); } } return _instance; } } private static readonly object SyncRoot = new object(); /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public override bool Compare(string obj1, string obj2, ComparisonSettings settings) { return string.Compare(obj1, obj2, StringComparison.CurrentCultureIgnoreCase) == 0; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/NulableStringsValueComparer.cs ================================================ namespace ObjectsComparer { /// /// Allows to compare strings considering that null and empty string are equal. /// public class NulableStringsValueComparer: AbstractValueComparer { private static volatile IValueComparer _instance; /// /// Static instance. /// public static IValueComparer Instance { get { if (_instance != null) { return _instance; } lock (SyncRoot) { if (_instance == null) { _instance = new NulableStringsValueComparer(); } } return _instance; } } private static readonly object SyncRoot = new object(); /// /// Comparers and . /// /// Object 1. /// Object 2. /// Instance of class. /// true if the objects are considered equal; otherwise, false. public override bool Compare(string obj1, string obj2, ComparisonSettings settings) { if (obj1 == null) { obj1 = string.Empty; } if (obj2 == null) { obj2 = string.Empty; } return obj1.Equals(obj2); } public override string ToString(string value) { return value ?? string.Empty; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/ToStringComparer.cs ================================================ namespace ObjectsComparer { public class ToStringComparer : DynamicValueComparer { public ToStringComparer() : base((uri1, uri2, settings) => uri1?.ToString() == uri2?.ToString()) { } } } ================================================ FILE: ObjectsComparer/ObjectsComparer/ValueComparers/UriComparer.cs ================================================ using System; namespace ObjectsComparer { public class UriComparer: DynamicValueComparer { private static volatile UriComparer _instance; /// /// Static instance. /// public static IValueComparer Instance { get { if (_instance != null) { return _instance; } lock (SyncRoot) { if (_instance == null) { _instance = new UriComparer(); } } return _instance; } } private static readonly object SyncRoot = new object(); public UriComparer() : base((uri1, uri2, settings) => uri1.OriginalString == uri2.OriginalString, (uri) => uri.OriginalString) { } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/BasicExamples/BasicExampleTests.cs ================================================ using System.Collections; using System.Collections.Generic; using System.Dynamic; using System.Globalization; using System.Linq; using System.Text; using NUnit.Framework; using static ObjectsComparer.Examples.OutputHelper; // ReSharper disable PossibleMultipleEnumeration namespace ObjectsComparer.Examples.BasicExamples { [TestFixture] public class BasicExampleTests { #region Basic [Test] public void BasicEquality() { var a1 = new ClassA { StringProperty = "String", IntProperty = 1 }; var a2 = new ClassA { StringProperty = "String", IntProperty = 1 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void BasicInequality() { var a1 = new ClassA { StringProperty = "String", IntProperty = 1 }; var a2 = new ClassA { StringProperty = "String", IntProperty = 2 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "IntProperty" && d.Value1 == "1" && d.Value2 == "2")); } [Test] public void BasicInequalityWhenSubclass() { var a1 = new ClassA { SubClass = new SubClassA { BoolProperty = true } }; var a2 = new ClassA { SubClass = new SubClassA { BoolProperty = false } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "SubClass.BoolProperty" && d.Value1 == "True" && d.Value2 == "False")); } #endregion #region Generic Enumerables [Test] public void GenericEnumerablesEquality() { var a1 = new[] { 1, 2, 3 }; var a2 = new[] { 1, 2, 3 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void GenericEnumerablesInequalityWhenDifferentLength() { var a1 = new[] { 1, 2 }; var a2 = new[] { 1, 2, 3 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Length" && d.Value1 == "2" && d.Value2 == "3")); } [Test] public void GenericEnumerablesInequalityWhenDifferentValue() { var a1 = new[] { 1, 2, 3 }; var a2 = new[] { 1, 4, 3 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "[1]" && d.Value1 == "2" && d.Value2 == "4")); } #endregion #region Hash Sets [Test] public void HashSetsEquality() { var a1 = new HashSet{ 1, 2, 3 }; var a2 = new HashSet { 1, 2, 3 }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void HashSetsInequality() { var a1 = new HashSet { 1, 2, 3 }; var a2 = new HashSet { 2, 1, 4 }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count()); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedElementInFirstObject && d.Value2 == "4")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedElementInSecondObject && d.Value1 == "3")); } #endregion #region String Builder [Test] public void StringBuilderEquality() { var a1 = new StringBuilder("abc"); var a2 = new StringBuilder("abc"); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void StringBuilderInequality() { var a1 = new StringBuilder("abc"); var a2 = new StringBuilder("abd"); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count()); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.Value1 == "abc" && d.Value2 == "abd")); } #endregion #region Non-Generic Enumerables [Test] public void NonGenericWhenDifferentTypes() { var a1 = new ArrayList { "Str1", "Str2" }; var a2 = new ArrayList { "Str1", 5 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual("[1]", differences.First().MemberPath); Assert.AreEqual(DifferenceTypes.TypeMismatch, differences.First().DifferenceType); Assert.AreEqual("Str2", differences.First().Value1); Assert.AreEqual("5", differences.First().Value2); } #endregion #region Multidimensional Arrays [Test] public void MultidimensionalArraysInequality() { var a1 = new[] { new[] { 1, 2 } }; var a2 = new[] { new[] { 1, 3 } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count()); Assert.AreEqual("[0][1]", differences.First().MemberPath); Assert.AreEqual("2", differences.First().Value1); Assert.AreEqual("3", differences.First().Value2); } [Test] public void MultidimensionalArraysSizeInequality1() { var a1 = new[] { new[] { 1, 2 } }; var a2 = new[] { new[] { 2, 2 }, new[] { 3, 5 } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count()); Assert.AreEqual("Length", differences.First().MemberPath); Assert.AreEqual("1", differences.First().Value1); Assert.AreEqual("2", differences.First().Value2); } [Test] public void MultidimensionalArraysSizeInequality2() { var a1 = new[] { new[] { 1, 2 }, new[] { 3, 5 } }; var a2 = new[] { new[] { 1, 2 }, new[] { 3, 5, 6 } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count()); Assert.AreEqual("[1].Length", differences.First().MemberPath); Assert.AreEqual("2", differences.First().Value1); Assert.AreEqual("3", differences.First().Value2); } [Test] public void IntIntInequality() { var a1 = new[,] { { 1, 2 } }; var a2 = new[,] { { 1, 3 } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count()); Assert.AreEqual("[0,1]", differences.First().MemberPath); Assert.AreEqual("2", differences.First().Value1); Assert.AreEqual("3", differences.First().Value2); } [Test] public void MultidimensionalArraysSizeInequality3() { var a1 = new[,] { { 1, 2 }, { 1, 3 } }; var a2 = new[,] { { 1, 3, 4 }, { 1, 3, 8 } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count()); Assert.AreEqual("Dimension1", differences.First().MemberPath); Assert.AreEqual("2", differences.First().Value1); Assert.AreEqual("3", differences.First().Value2); } #endregion #region Dynamic objects (ExpandoObject) [Test] public void ExpandoObject() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 5; a1.Field4 = 4; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field3 = false; a2.Field4 = "C"; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(4, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject && d.MemberPath == "Field2" && d.Value1 == "5")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject && d.MemberPath == "Field3" && d.Value2 == "False")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.TypeMismatch && d.MemberPath == "Field4" && d.Value1 == "4" && d.Value2 == "C")); } [Test] public void ExpandoObjectWhenMissedFieldsAndUseDefaults() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 0; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field3 = false; a2.Field4 = "S"; var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); var isEqual = comparer.Compare(a1, a2, out IEnumerable differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.MemberPath == "Field4" && d.Value2 == "S")); } #endregion #region Dynamic objects (DynamicObject) private class DynamicDictionary : DynamicObject { // ReSharper disable once UnusedMember.Local public int IntProperty { get; set; } private readonly Dictionary _dictionary = new Dictionary(); public override bool TryGetMember(GetMemberBinder binder, out object result) { var name = binder.Name; return _dictionary.TryGetValue(name, out result); } public override bool TrySetMember(SetMemberBinder binder, object value) { _dictionary[binder.Name] = value; return true; } public override IEnumerable GetDynamicMemberNames() { return _dictionary.Keys; } } [Test] public void DynamicObject() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; a1.Field3 = true; dynamic a2 = new DynamicDictionary(); a2.Field1 = "B"; a2.Field2 = 8; a2.Field3 = 1; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject && d.MemberPath == "Field2" && d.Value2 == "8")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.TypeMismatch && d.MemberPath == "Field3" && d.Value1 == "True" && d.Value2 == "1")); } #endregion #region Dynamic objects (compiler generated) [Test] public void CompilerGeneratedDynamicObjects() { dynamic a1 = new { Field1 = "A", Field2 = 5, Field3 = true }; dynamic a2 = new { Field1 = "B", Field2 = 8.0 }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.TypeMismatch && d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == 8.0.ToString(CultureInfo.InvariantCulture))); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject && d.MemberPath == "Field3" && d.Value1 == "True")); } #endregion #region Overrides public class MyValueComparer : AbstractValueComparer { public override bool Compare(string obj1, string obj2, ComparisonSettings settings) { return obj1 == obj2; //Implement comparison logic here } } [Test] public void Overrides() { var comparer = new Comparer(); // Type //Use MyComparer to compare all members of type string comparer.AddComparerOverride(new MyValueComparer()); comparer.AddComparerOverride(typeof(string), new MyValueComparer()); //Use MyComparer to compare all members of type string except members which name starts with "Xyz" comparer.AddComparerOverride(new MyValueComparer(), member => !member.Name.StartsWith("Xyz")); // Member Info //Use MyValueComparer to compare StringProperty of ClassA //comparer.AddComparerOverride(() => new ClassA().StringProperty, new MyValueComparer()); //comparer.AddComparerOverride( // typeof(ClassA).GetTypeInfo().GetMember("StringProperty").First(), // new MyValueComparer()); //Compare StringProperty of ClassA by length. If length equal consider that values are equal //comparer.AddComparerOverride( // () => new ClassA().StringProperty, // (s1, s2, parentSettings) => s1?.Length == s2?.Length, // s => s?.ToString()); //comparer.AddComparerOverride( // () => new ClassA().StringProperty, // (s1, s2, parentSettings) => s1?.Length == s2?.Length); // Member filter //comparer.AddComparerOverride(new MyValueComparer(), m => m.Name == "StringProperty"); // Member Name comparer.AddComparerOverride("StringProperty", new MyValueComparer()); //Exception comparer.AddComparerOverride(new MyValueComparer(), member => member.Name.StartsWith("String")); comparer.AddComparerOverride(DoNotCompareValueComparer.Instance, member => member.Name.EndsWith("Property")); //var result = comparer.Compare(a1, a2);//Exception here } #endregion } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/BasicExamples/ClassA.cs ================================================ namespace ObjectsComparer.Examples.BasicExamples { public class ClassA { public string StringProperty { get; set; } public int IntProperty { get; set; } public SubClassA SubClass { get; set; } } public class SubClassA { public bool BoolProperty { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example1/Error.cs ================================================ namespace ObjectsComparer.Examples.Example1 { public class Error { public int Id { get; set; } public string Messgae { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example1/Example1Tests.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using NUnit.Framework; using static ObjectsComparer.Examples.OutputHelper; // ReSharper disable PossibleMultipleEnumeration namespace ObjectsComparer.Examples.Example1 { [TestFixture] public class Example1Tests { private IComparer _comparer; [SetUp] public void SetUp() { _comparer = new Comparer( new ComparisonSettings { //Null and empty error lists are equal EmptyAndNullEnumerablesEqual = true }); //Do not compare Dates _comparer.AddComparerOverride(DoNotCompareValueComparer.Instance); //Do not compare Id _comparer.AddComparerOverride(() => new Message().Id, DoNotCompareValueComparer.Instance); //Do not compare Message Text _comparer.AddComparerOverride(() => new Error().Messgae, DoNotCompareValueComparer.Instance); } [Test] public void EqualMessagesWithoutErrors() { var expectedMessage = new Message { MessageType = 1, Status = 0 }; var actualMessage = new Message { Id = "M12345", DateCreated = DateTime.Now, DateReceived = DateTime.Now, DateSent = DateTime.Now, MessageType = 1, Status = 0 }; var isEqual = _comparer.Compare(expectedMessage, actualMessage, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void EqualMessagesWithErrors() { var expectedMessage = new Message { MessageType = 1, Status = 1, Errors = new List { new Error { Id = 2 }, new Error { Id = 7 } } }; var actualMessage = new Message { Id = "M12345", DateCreated = DateTime.Now, DateReceived = DateTime.Now, DateSent = DateTime.Now, MessageType = 1, Status = 1, Errors = new List { new Error { Id = 2, Messgae = "Some error #2" }, new Error { Id = 7, Messgae = "Some error #7" } } }; var isEqual = _comparer.Compare(expectedMessage, actualMessage, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void UnequalMessages() { var expectedMessage = new Message { MessageType = 1, Status = 1, Errors = new List { new Error { Id = 2, Messgae = "Some error #2" }, new Error { Id = 8, Messgae = "Some error #8" } } }; var actualMessage = new Message { Id = "M12345", DateCreated = DateTime.Now, DateReceived = DateTime.Now, DateSent = DateTime.Now, MessageType = 1, Status = 2, Errors = new List { new Error { Id = 2, Messgae = "Some error #2" }, new Error { Id = 7, Messgae = "Some error #7" } } }; var isEqual = _comparer.Compare(expectedMessage, actualMessage, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Status" && d.Value1 == "1" && d.Value2 == "2")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Errors[1].Id" && d.Value1 == "8" && d.Value2 == "7")); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example1/Message.cs ================================================ using System; using System.Collections.Generic; namespace ObjectsComparer.Examples.Example1 { public class Message { public string Id { get; set; } public DateTime DateCreated { get; set; } public DateTime DateSent { get; set; } public DateTime DateReceived { get; set; } public int MessageType { get; set; } public int Status { get; set; } public List Errors { get; set; } public override string ToString() { return $"Id:{Id}, Type:{MessageType}, Status:{Status}"; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example2/Example2Tests.cs ================================================ using System; using System.Linq; using NUnit.Framework; using static ObjectsComparer.Examples.OutputHelper; // ReSharper disable PossibleMultipleEnumeration namespace ObjectsComparer.Examples.Example2 { [TestFixture] public class Example2Tests { private MyComparersFactory _factory; private IComparer _comparer; [SetUp] public void SetUp() { _factory = new MyComparersFactory(); _comparer = _factory.GetObjectsComparer(); } [Test] public void EqualPersonsTest() { var person1 = new Person { PersonId = Guid.NewGuid(), FirstName = "John", LastName = "Doe", MiddleName = "F", PhoneNumber = "111-555-8888" }; var person2 = new Person { PersonId = Guid.NewGuid(), FirstName = "John", LastName = "Doe", PhoneNumber = "(111) 555 8888" }; var isEqual = _comparer.Compare(person1, person2, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void DifferentPersonsTest() { var person1 = new Person { PersonId = Guid.NewGuid(), FirstName = "Jack", LastName = "Doe", MiddleName = "F", PhoneNumber = "111-555-8888" }; var person2 = new Person { PersonId = Guid.NewGuid(), FirstName = "John", LastName = "Doe", MiddleName = "L", PhoneNumber = "222-555-9999" }; var isEqual = _comparer.Compare(person1, person2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "FirstName" && d.Value1 == "Jack" && d.Value2 == "John")); Assert.IsTrue(differences.Any(d => d.MemberPath == "MiddleName" && d.Value1 == "F" && d.Value2 == "L")); Assert.IsTrue(differences.Any(d => d.MemberPath == "PhoneNumber" && d.Value1 == "111-555-8888" && d.Value2 == "222-555-9999")); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example2/MyComparersFactory.cs ================================================ using System; namespace ObjectsComparer.Examples.Example2 { public class MyComparersFactory : ComparersFactory { public override IComparer GetObjectsComparer(ComparisonSettings settings = null, BaseComparer parentComparer = null) { if (typeof(T) != typeof(Person)) { return base.GetObjectsComparer(settings, parentComparer); } var comparer = new Comparer(settings, parentComparer, this); //Do not compare PersonId comparer.AddComparerOverride(DoNotCompareValueComparer.Instance); //Sometimes MiddleName can be skipped. Compare only if property has value. comparer.AddComparerOverride( () => new Person().MiddleName, (s1, s2, parentSettings) => string.IsNullOrWhiteSpace(s1) || string.IsNullOrWhiteSpace(s2) || s1 == s2); comparer.AddComparerOverride( () => new Person().PhoneNumber, new PhoneNumberComparer()); return (IComparer) comparer; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example2/Person.cs ================================================ using System; namespace ObjectsComparer.Examples.Example2 { public class Person { public Guid PersonId { get; set; } public string FirstName { get; set; } public string LastName { get; set; } public string MiddleName { get; set; } public string PhoneNumber { get; set; } public override string ToString() { return $"{FirstName} {MiddleName} {LastName} ({PhoneNumber})"; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example2/PhoneNumberComparer.cs ================================================ using System.Linq; namespace ObjectsComparer.Examples.Example2 { public class PhoneNumberComparer: AbstractValueComparer { public override bool Compare(string obj1, string obj2, ComparisonSettings settings) { return ExtractDigits(obj1) == ExtractDigits(obj2); } private string ExtractDigits(string str) { return string.Join( string.Empty, (str ?? string.Empty) .ToCharArray() .Where(char.IsDigit)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example3/Example3Tests.cs ================================================ using System; using System.Dynamic; using System.IO; using System.Linq; using System.Reflection; using System.Text; using Newtonsoft.Json; using NUnit.Framework; using static ObjectsComparer.Examples.OutputHelper; // ReSharper disable PossibleMultipleEnumeration namespace ObjectsComparer.Examples.Example3 { [TestFixture] public class Example3Tests { private Comparer _comparer; [SetUp] public void SetUp() { _comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); //Some fields should be ignored _comparer.AddComparerOverride("ConnectionString", DoNotCompareValueComparer.Instance); _comparer.AddComparerOverride("Email", DoNotCompareValueComparer.Instance); _comparer.AddComparerOverride("Notifications", DoNotCompareValueComparer.Instance); //Smart Modes are disabled by default. These fields are not case sensitive var disabledByDefaultComparer = new DefaultValueValueComparer("Disabled", IgnoreCaseStringsValueComparer.Instance); _comparer.AddComparerOverride("SmartMode1", disabledByDefaultComparer); _comparer.AddComparerOverride("SmartMode2", disabledByDefaultComparer); _comparer.AddComparerOverride("SmartMode3", disabledByDefaultComparer); //http prefix in URLs should be ignored var urlComparer = new DynamicValueComparer( (url1, url2, settings) => url1.Trim('/').Replace(@"http://", string.Empty) == url2.Trim('/').Replace(@"http://", string.Empty)); _comparer.AddComparerOverride("SomeUrl", urlComparer); _comparer.AddComparerOverride("SomeOtherUrl", urlComparer); //DataCompression is Off by default. _comparer.AddComparerOverride("DataCompression", new DefaultValueValueComparer("Off", NulableStringsValueComparer.Instance)); //ProcessTaskTimeout and TotalProcessTimeout fields have default values. _comparer.AddComparerOverride("ProcessTaskTimeout", new DefaultValueValueComparer(100, DefaultValueComparer.Instance)); _comparer.AddComparerOverride("TotalProcessTimeout", new DefaultValueValueComparer(500, DefaultValueComparer.Instance)); } [Test] public void Settings1() { var settings0Json = LoadJson("Settings0.json"); var settings0 = JsonConvert.DeserializeObject(settings0Json); var settings1Json = LoadJson("Settings1.json"); var settings1 = JsonConvert.DeserializeObject(settings1Json); var isEqual = _comparer.Compare(settings0, settings1, out var differences); ResultToOutput(isEqual, differences); Assert.IsTrue(isEqual); } [Test] public void Settings2() { var settings0Json = LoadJson("Settings0.json"); var settings0 = JsonConvert.DeserializeObject(settings0Json); var settings2Json = LoadJson("Settings2.json"); var settings2 = JsonConvert.DeserializeObject(settings2Json); var isEqual = _comparer.Compare(settings0, settings2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(8, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Settings.DataCompression" && d.Value1 == "On" && d.Value2 == "Off")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Settings.SuperModes.SmartMode1" && d.Value1 == "Enabled" && d.Value2 == "Disabled")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Timeouts.ProcessTaskTimeout" && d.Value1 == "100" && d.Value2 == "200")); Assert.IsTrue(differences.Any(d => d.MemberPath == "BackupSettings.BackupIntervalUnit" && d.Value1 == "Day" && d.Value2 == "Week")); Assert.IsTrue(differences.Any(d => d.MemberPath == "BackupSettings.BackupInterval" && d.Value1 == "100" && d.Value2 == "2")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Logging.Enabled" && d.Value1 == "True" && d.Value2 == "False")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Logging.MaximumFileSize" && d.Value1 == "20MB" && d.Value2 == "40MB")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Logging.Level" && d.Value1 == "ALL" && d.Value2 == "ERROR")); } private string LoadJson(string fileName) { var resourceStream = typeof(Example3Tests).GetTypeInfo() .Assembly.GetManifestResourceStream("ObjectsComparer.Examples.Example3." + fileName); if (resourceStream == null) { throw new Exception($"Resource '{fileName}' not found"); } using (var reader = new StreamReader(resourceStream, Encoding.UTF8)) { return reader.ReadToEnd(); } } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example3/Settings0.json ================================================ { "ConnectionString": "USER ID=superuser;PASSWORD=superpassword;DATA SOURCE=localhost:1111", "Email": { "Port": 25, "Host": "MyHost.com", "EmailAddress": "test@MyHost.com" }, "Settings": { "DataCompression": "On", "DataSourceType": "MultiDataSource", "SomeUrl": "http://MyHost.com/VeryImportantData", "SomeOtherUrl": "http://MyHost.com/NotSoImportantData/", "CacheMode": "Memory", "MaxCacheSize": "1GB", "SuperModes": { "SmartMode1": "Enabled", "SmartMode2": "Disabled", "SmartMode3": "Enabled" } }, "Timeouts": { "TotalProcessTimeout": 500, "ProcessTaskTimeout": 100 }, "BackupSettings": { "BackupIntervalUnit": "Day", "BackupInterval": 100 }, "Notifications": [ { "Phone": "111-222-3333" }, { "Phone": "111-222-4444" }, { "EMail": "support@MyHost.com" } ], "Logging": { "Enabled": true, "Pattern": "Logs\\MyApplication.%data{yyyyMMdd}.log", "MaximumFileSize": "20MB", "Level": "ALL" } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example3/Settings1.json ================================================ { "ConnectionString": "USER ID=admin;PASSWORD=*****;DATA SOURCE=localhost:22222", "Email": { "Port": 25, "Host": "MyHost.com", "EmailAddress": "test@MyHost.com" }, "Settings": { "DataCompression": "On", "DataSourceType": "MultiDataSource", "SomeUrl": "MyHost.com/VeryImportantData", "SomeOtherUrl": "MyHost.com/NotSoImportantData/", "CacheMode": "Memory", "MaxCacheSize": "1GB", "SuperModes": { "SmartMode1": "enabled", "SmartMode3": "enabled" } }, "BackupSettings": { "BackupIntervalUnit": "Day", "BackupInterval": 100 }, "Notifications": [ { "Phone": "111-222-3333" }, { "EMail": "support@MyHost.com" } ], "Logging": { "Enabled": true, "Pattern": "Logs\\MyApplication.%data{yyyyMMdd}.log", "MaximumFileSize": "20MB", "Level": "ALL" } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example3/Settings2.json ================================================ { "ConnectionString": "USER ID=superuser;PASSWORD=superpassword;DATA SOURCE=localhost:1111", "Email": { "Port": 25, "Host": "MyHost.com", "EmailAddress": "test@MyHost.com" }, "Settings": { "DataSourceType": "MultiDataSource", "SomeUrl": "http://MyHost.com/VeryImportantData", "SomeOtherUrl": "http://MyHost.com/NotSoImportantData/", "CacheMode": "Memory", "MaxCacheSize": "1GB", "SuperModes": { "SmartMode3": "Enabled" } }, "Timeouts": { "TotalProcessTimeout": 500, "ProcessTaskTimeout": 200 }, "BackupSettings": { "BackupIntervalUnit": "Week", "BackupInterval": 2 }, "Notifications": [ { "EMail": "support@MyHost.com" } ], "Logging": { "Enabled": false, "Pattern": "Logs\\MyApplication.%data{yyyyMMdd}.log", "MaximumFileSize": "40MB", "Level": "ERROR" } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example4/CustomFormulaItemsComparer.cs ================================================ using System.Collections.Generic; using System.Linq; namespace ObjectsComparer.Examples.Example4 { public class CustomFormulaItemsComparer: AbstractComparer> { public CustomFormulaItemsComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(IList obj1, IList obj2) { if (obj1 == null && obj2 == null) { yield break; } if (obj1 == null || obj2 == null) { yield return new Difference("", DefaultValueComparer.ToString(obj1) , DefaultValueComparer.ToString(obj2)); yield break; } if (obj1.Count != obj2.Count) { yield return new Difference("Count", obj1.Count.ToString(), obj2.Count.ToString(), DifferenceTypes.NumberOfElementsMismatch); } foreach (var formulaItem in obj1) { var formulaItem2 = obj2.FirstOrDefault(fi => fi.Id == formulaItem.Id); if (formulaItem2 != null) { var comparer = Factory.GetObjectsComparer(); foreach (var difference in comparer.CalculateDifferences(formulaItem, formulaItem2)) { yield return difference.InsertPath($"[Id={formulaItem.Id}]"); } } } } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example4/Example4Tests.cs ================================================ using System.Collections.Generic; using System.Linq; using NUnit.Framework; using static ObjectsComparer.Examples.OutputHelper; // ReSharper disable PossibleMultipleEnumeration namespace ObjectsComparer.Examples.Example4 { [TestFixture] public class Example4Tests { private MyComparersFactory _factory; private IComparer _comparer; [SetUp] public void SetUp() { _factory = new MyComparersFactory(); _comparer = _factory.GetObjectsComparer(); } [Test] public void List_Of_Equal_Sizes_But_Is_Inequality() { var formula1 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 60, Name = "Item 1", Instruction = "Instruction 1" } } }; var formula2 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 80, Name = "Item One", Instruction = "Instruction One" } } }; var isEqual = _comparer.Compare(formula1, formula2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Items[Id=1].Delay" && d.Value1 == "60" && d.Value2 == "80")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Items[Id=1].Name" && d.Value1 == "Item 1" && d.Value2 == "Item One")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Items[Id=1].Instruction" && d.Value1 == "Instruction 1" && d.Value2 == "Instruction One")); } [Test] public void List_Of_Different_Sizes_But_Is_Inequality() { var formula1 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 60, Name = "Item 1", Instruction = "Instruction 1" } } }; var formula2 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 80, Name = "Item One", Instruction = "Instruction One" }, new FormulaItem { Id = 2, Delay = 30, Name = "Item Two", Instruction = "Instruction Two" } } }; var isEqual = _comparer.Compare(formula1, formula2, out var differences); ResultToOutput(isEqual, differences); Assert.IsFalse(isEqual); Assert.AreEqual(4, differences.Count()); Assert.IsTrue(differences.Any(d => d.MemberPath == "Items.Count" && d.Value1 == "1" && d.Value2 == "2")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Items[Id=1].Delay" && d.Value1 == "60" && d.Value2 == "80")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Items[Id=1].Name" && d.Value1 == "Item 1" && d.Value2 == "Item One")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Items[Id=1].Instruction" && d.Value1 == "Instruction 1" && d.Value2 == "Instruction One")); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example4/Formula.cs ================================================ using System.Collections.Generic; namespace ObjectsComparer.Examples.Example4 { public class Formula { public long Id { get; set; } public string Name { get; set; } public IList Items { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example4/FormulaItem.cs ================================================ namespace ObjectsComparer.Examples.Example4 { public class FormulaItem { public long Id { get; set; } public int Delay { get; set; } public string Name { get; set; } public string Instruction { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example4/MyComparersFactory.cs ================================================ using System.Collections.Generic; namespace ObjectsComparer.Examples.Example4 { public class MyComparersFactory : ComparersFactory { public override IComparer GetObjectsComparer(ComparisonSettings settings = null, BaseComparer parentComparer = null) { if (typeof(T) != typeof(IList)) { return base.GetObjectsComparer(settings, parentComparer); } var comparer = new CustomFormulaItemsComparer(settings, parentComparer, this); return (IComparer) comparer; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example5/Error.cs ================================================ namespace ObjectsComparer.Examples.Example5 { public class Error { [Ignore] public int Id { get; set; } public string Messgae { get; set; } [Ignore] public string Details { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example5/Example5Tests.cs ================================================ using NUnit.Framework; namespace ObjectsComparer.Examples.Example5 { [TestFixture] public class Example5Tests { [Test] public void IgnoreByAttribute() { var error1 = new Error { Id = 1, Messgae = "Error Message", Details = "Error details" }; var error2 = new Error { Id = 2, Messgae = "Error Message", Details = "Other error details" }; var comparer = new Comparer(); comparer.IgnoreMember(m => m.GetCustomAttributes(typeof(IgnoreAttribute), true).Length > 0); var isEqual = comparer.Compare(error1, error2); Assert.IsTrue(isEqual); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/Example5/IgnoreAttribute.cs ================================================ using System; namespace ObjectsComparer.Examples.Example5 { [AttributeUsage(AttributeTargets.Property)] public class IgnoreAttribute: Attribute { } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/ObjectsComparer.Examples.csproj ================================================  netcoreapp2.0;net45 Never Never Never ================================================ FILE: ObjectsComparer/ObjectsComparer.Examples/OutputHelper.cs ================================================ using System; using System.Collections.Generic; using System.Diagnostics; namespace ObjectsComparer.Examples { public static class OutputHelper { public static void ResultToOutput(bool isEqual, IEnumerable differenses) { Debug.WriteLine(isEqual ? "Objects are equal" : string.Join(Environment.NewLine, differenses)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/AbstractComparerGenericTests.cs ================================================ using System.Collections.Generic; using NSubstitute; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class AbstractComparerGenericTests { private BaseComparer _parentComparerMock; private IComparersFactory _factoryMock; private AbstractComparer _comparer; [SetUp] public void SetUp() { _factoryMock = Substitute.For(); _parentComparerMock = Substitute.ForPartsOf(new ComparisonSettings(), null, _factoryMock); _comparer = Substitute.ForPartsOf>(new ComparisonSettings(), _parentComparerMock, _factoryMock); } [Test] public void CalculateDifferences() { _comparer.CalculateDifferences(1, 2); _comparer.Received().CalculateDifferences(1, 2); } [Test] public void CompareWithOutParameterWhenNotEqual() { var differences = new List { new Difference("", "1", "2") }; _comparer.CalculateDifferences(1, 2).Returns(differences); var result = _comparer.Compare(1, 2, out var outDifferences); Assert.IsFalse(result); _comparer.Received().CalculateDifferences(1, 2); Assert.AreEqual(differences, outDifferences); } [Test] public void CompareWithOutParameterWhenEqual() { var differences = new List(); _comparer.CalculateDifferences(1, 1).Returns(differences); var result = _comparer.Compare(1, 1, out var outDifferences); Assert.IsTrue(result); _comparer.Received().CalculateDifferences(1, 1); Assert.AreEqual(differences, outDifferences); } [Test] public void CompareWithoutOutParameterWhenNotEqual() { var differences = new List { new Difference("", "1", "2") }; _comparer.CalculateDifferences(1, 2).Returns(differences); var result = _comparer.Compare(1, 2); Assert.IsFalse(result); _comparer.Received().CalculateDifferences(1, 2); } [Test] public void CompareWithoutOutParameterWhenEqual() { _comparer.CalculateDifferences(1, 2).Returns(new List()); var result = _comparer.Compare(1, 2); Assert.IsTrue(result); _comparer.Received().CalculateDifferences(1, 2); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/AbstractComparerTests.cs ================================================ using System.Collections.Generic; using NSubstitute; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class AbstractComparerTests { private BaseComparer _parentComparerMock; private IComparersFactory _factoryMock; private AbstractComparer _comparer; [SetUp] public void SetUp() { _factoryMock = Substitute.For(); _parentComparerMock = Substitute.ForPartsOf(new ComparisonSettings(), null, _factoryMock); _comparer = Substitute.ForPartsOf(new ComparisonSettings(), _parentComparerMock, _factoryMock); } [Test] public void CalculateDifferences() { _comparer.CalculateDifferences("string1", "string2"); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string2"); } [Test] public void CompareWithOutParameterWhenNotEqual() { var differences = new List {new Difference("", "string1", "string2")}; _comparer.CalculateDifferences(typeof(string), "string1", "string2").Returns(differences); var result = _comparer.Compare("string1", "string2", out var outDifferences); Assert.IsFalse(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string2"); Assert.AreEqual(differences, outDifferences); } [Test] public void CompareWithOutParameterWhenEqual() { var differences = new List(); _comparer.CalculateDifferences(typeof(string), "string1", "string1").Returns(differences); var result = _comparer.Compare("string1", "string1", out var outDifferences); Assert.IsTrue(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string1"); Assert.AreEqual(differences, outDifferences); } [Test] public void CompareWithoutOutParameterWhenNotEqual() { var differences = new List {new Difference("", "string1", "string2")}; _comparer.CalculateDifferences(typeof(string), "string1", "string2").Returns(differences); var result = _comparer.Compare("string1", "string2"); Assert.IsFalse(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string2"); } [Test] public void CompareWithoutOutParameterWhenEqual() { _comparer.CalculateDifferences(typeof(string), "string1", "string2").Returns(new List()); var result = _comparer.Compare("string1", "string2"); Assert.IsTrue(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string2"); } [Test] public void NonGenericCompareWithOutParameterWhenNotEqual() { var differences = new List {new Difference("", "string1", "string2")}; _comparer.CalculateDifferences(typeof(string), "string1", "string2").Returns(differences); var result = _comparer.Compare(typeof(string), "string1", "string2", out var outDifferences); Assert.IsFalse(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string2"); Assert.AreEqual(differences, outDifferences); } [Test] public void NonGenericCompareWithOutParameterWhenEqual() { var differences = new List(); _comparer.CalculateDifferences(typeof(string), "string1", "string1").Returns(differences); var result = _comparer.Compare(typeof(string), "string1", "string1", out var outDifferences); Assert.IsTrue(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string1"); Assert.AreEqual(differences, outDifferences); } [Test] public void NonGenericCompareWithoutOutParameterWhenNotEqual() { var differences = new List {new Difference("", "string1", "string2")}; _comparer.CalculateDifferences(typeof(string), "string1", "string2").Returns(differences); var result = _comparer.Compare(typeof(string), "string1", "string2"); Assert.IsFalse(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string2"); } [Test] public void NonGenericCompareWithoutOutParameterWhenEqual() { _comparer.CalculateDifferences(typeof(string), "string1", "string2").Returns(new List()); var result = _comparer.Compare(typeof(string), "string1", "string2"); Assert.IsTrue(result); _comparer.Received().CalculateDifferences(typeof(string), "string1", "string2"); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ComparerNonGenericTests.cs ================================================ using System; using System.Linq; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerNonGenericTests { [Test] public void PropertyEquality() { var a1 = new A { IntProperty = 10, DateTimeProperty = new DateTime(2017, 1, 1), Property3 = 5 }; var a2 = new A { IntProperty = 10, DateTimeProperty = new DateTime(2017, 1, 1), Property3 = 8 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void PropertyInequality() { var date1 = new DateTime(2017, 1, 1); var date2 = new DateTime(2017, 1, 2); var a1 = new A { IntProperty = 10, DateTimeProperty = date1 }; var a2 = new A { IntProperty = 8, DateTimeProperty = date2 }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("IntProperty", differences[0].MemberPath); Assert.AreEqual("10", differences[0].Value1); Assert.AreEqual("8", differences[0].Value2); Assert.AreEqual("DateTimeProperty", differences[1].MemberPath); // ReSharper disable once SpecifyACultureInStringConversionExplicitly Assert.AreEqual(date1.ToString(), differences[1].Value1); // ReSharper disable once SpecifyACultureInStringConversionExplicitly Assert.AreEqual(date2.ToString(), differences[1].Value2); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ComparerOverridesCollectionTests.cs ================================================ using System; using System.Reflection; using NSubstitute; using NUnit.Framework; using ObjectsComparer.Exceptions; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerOverridesCollectionTests { [Test] public void AddComparerByMemberInfoWhenMemberNull() { var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); // ReSharper disable once RedundantCast Assert.Throws(() => collection.AddComparer((MemberInfo)null, valueComparer)); } [Test] public void AddComparerByMemberInfoWhenComparerNull() { var memberInfo = Substitute.ForPartsOf(); var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.AddComparer(memberInfo, null)); } [Test] public void AddComparerByMemberInfoWhenExists() { var memberInfo = Substitute.ForPartsOf(); var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer(memberInfo, valueComparer); var exception = Assert.Throws(() => collection.AddComparer(memberInfo, valueComparer)); Assert.AreEqual(memberInfo, exception.MemberInfo); } [Test] public void GetOverrideByMemberInfoComparer() { var memberInfo1 = Substitute.ForPartsOf(); memberInfo1.PropertyType.Returns(typeof(string)); var valueComparer1 = Substitute.For(); var memberInfo2 = Substitute.ForPartsOf(); memberInfo2.PropertyType.Returns(typeof(string)); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer(memberInfo1, valueComparer1); collection.AddComparer(memberInfo2, valueComparer2); var valueComparer1FromCollection = collection.GetComparer(memberInfo1); var valueComparer2FromCollection = collection.GetComparer(memberInfo2); Assert.AreEqual(valueComparer1, valueComparer1FromCollection); Assert.AreEqual(valueComparer2, valueComparer2FromCollection); } [Test] public void GetComparerByMemberInfoWhenNotExists() { var memberInfo1 = Substitute.ForPartsOf(); memberInfo1.PropertyType.Returns(typeof(string)); var valueComparer1 = Substitute.For(); var memberInfo2 = Substitute.ForPartsOf(); memberInfo2.PropertyType.Returns(typeof(string)); var collection = new ComparerOverridesCollection(); collection.AddComparer(memberInfo1, valueComparer1); var valueComparer2FromCollection = collection.GetComparer(memberInfo2); Assert.IsNull(valueComparer2FromCollection); } [Test] public void AddComparerByTypeWhenTypeNull() { var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.AddComparer((Type)null, valueComparer)); } [Test] public void AddComparerByTypeWhenComparerNull() { var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.AddComparer(typeof(string), null)); } [Test] public void GetOverrideByTypeComparerByMemberInfo() { var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); collection.AddComparer(typeof(string), valueComparer); var valueComparerFromCollection = collection.GetComparer(memberInfo); Assert.AreEqual(valueComparer, valueComparerFromCollection); } [Test] public void GetOverrideByTypeComparerByType() { var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); collection.AddComparer(typeof(string), valueComparer); var valueComparerFromCollection = collection.GetComparer(typeof(string)); Assert.AreEqual(valueComparer, valueComparerFromCollection); } [Test] public void GetComparerByTypeWhenNull() { var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.GetComparer((Type)null)); } [Test] public void GetOverrideByTypeComparerWhenTwoComparersMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); memberInfo.Name.Returns("Prop1"); collection.AddComparer(typeof(string), valueComparer1); collection.AddComparer(typeof(string), valueComparer2, mi => mi.Name == "Prop1"); var exception = Assert.Throws(() => collection.GetComparer(memberInfo)); Assert.AreEqual(memberInfo, exception.MemberInfo); Assert.AreEqual("Prop1", exception.MemberName); } [Test] public void GetOverrideByTypeComparerWhenOneComparerMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); memberInfo.Name.Returns("Prop1"); collection.AddComparer(typeof(string), valueComparer1, mi => mi.Name == "Prop1"); collection.AddComparer(typeof(string), valueComparer2, mi => mi.Name == "Prop2"); var valueComparerFromCollection = collection.GetComparer(memberInfo); Assert.AreEqual(valueComparer1, valueComparerFromCollection); } [Test] public void GetOverrideByTypeComparerWhenNoComparerMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); memberInfo.Name.Returns("Prop1"); collection.AddComparer(typeof(string), valueComparer1, mi => false); collection.AddComparer(typeof(string), valueComparer2, mi => false); var valueComparerFromCollection = collection.GetComparer(memberInfo); Assert.IsNull(valueComparerFromCollection); } [Test] public void GetOverrideByTypeWhenOnlyOneComparerDoNotHaveFilter() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer(typeof(string), valueComparer1, mi => true); collection.AddComparer(typeof(string), valueComparer2); var valueComparerFromCollection = collection.GetComparer(typeof(string)); Assert.AreEqual(valueComparer2, valueComparerFromCollection); } [Test] public void GetOverrideByTypeWhenMoreThanOneComparerMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer(typeof(string), valueComparer1); collection.AddComparer(typeof(string), valueComparer2); var exception = Assert.Throws(() => collection.GetComparer(typeof(string))); Assert.AreEqual(typeof(string), exception.Type); } [Test] public void GetOverrideByTypeWhenNoComparerMatchCriteria() { var valueComparer1 = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer(typeof(string), valueComparer1); var valueComparerFromCollection = collection.GetComparer(typeof(int)); Assert.IsNull(valueComparerFromCollection); } [Test] public void GetOverrideByTypeWhenAllComparersHaveFilters() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer(typeof(string), valueComparer1, mi => true); collection.AddComparer(typeof(string), valueComparer2, mi => true); var valueComparerFromCollection = collection.GetComparer(typeof(string)); Assert.IsNull(valueComparerFromCollection); } [TestCase(null)] [TestCase("")] [TestCase(" ")] public void AddComparerByNameWhenNameEmpty(string memberName) { var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.AddComparer(memberName, valueComparer)); } [Test] public void AddComparerByNameWhenComparerNull() { var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.AddComparer("Name", null)); } [Test] public void GetOverrideByNameComparerByMemberInfo() { var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); memberInfo.Name.Returns("Prop1"); collection.AddComparer("Prop1", valueComparer); var valueComparerFromCollection = collection.GetComparer(memberInfo); Assert.AreEqual(valueComparer, valueComparerFromCollection); } [Test] public void GetOverrideByNameComparerByMemberInfoWhenTwoComparersMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); memberInfo.Name.Returns("Prop1"); collection.AddComparer("Prop1", valueComparer1); collection.AddComparer("Prop1", valueComparer2, mi => true); Assert.Throws(() => collection.GetComparer(memberInfo)); } [Test] public void GetOverrideByNameComparerByMemberInfoWhenNoComparerMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); memberInfo.Name.Returns("Prop1"); collection.AddComparer("Prop1", valueComparer1, mi => false); collection.AddComparer("Prop1", valueComparer2, mi => false); var valueComparerFromCollection = collection.GetComparer(memberInfo); Assert.IsNull(valueComparerFromCollection); } [Test] public void GetOverrideByNameComparerByMemberInfoWhenOneComparerMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); var memberInfo = Substitute.ForPartsOf(); memberInfo.PropertyType.Returns(typeof(string)); memberInfo.Name.Returns("Prop1"); collection.AddComparer("Prop1", valueComparer1, mi => false); collection.AddComparer("Prop1", valueComparer2, mi => true); var valueComparerFromCollection = collection.GetComparer(memberInfo); Assert.AreEqual(valueComparer2, valueComparerFromCollection); } [Test] public void GetComparerByMemberInfoWhenNull() { var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.GetComparer((MemberInfo)null)); } [Test] public void GetOverrideByNameComparerByMemberName() { var valueComparer = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer("Prop1", valueComparer); var valueComparerFromCollection = collection.GetComparer("Prop1"); Assert.AreEqual(valueComparer, valueComparerFromCollection); } [Test] public void GetOverrideByNameComparerByMemberNameWhenTwoComparersMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer("Prop1", valueComparer1); collection.AddComparer("Prop1", valueComparer2); Assert.Throws(() => collection.GetComparer("Prop1")); } [Test] public void GetOverrideByNameComparerByMemberNameWhenNoComparerMatchCriteria() { var valueComparer1 = Substitute.For(); var valueComparer2 = Substitute.For(); var collection = new ComparerOverridesCollection(); collection.AddComparer("Prop1", valueComparer1, mi => false); collection.AddComparer("Prop1", valueComparer2, mi => false); var valueComparerFromCollection = collection.GetComparer("Prop1"); Assert.IsNull(valueComparerFromCollection); } [Test] public void GetComparerByMemberNameWhenNull() { var collection = new ComparerOverridesCollection(); Assert.Throws(() => collection.GetComparer((string)null)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ComparerTests.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using NSubstitute; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerTests { [Test] public void PropertyEquality() { var a1 = new A {IntProperty = 10, DateTimeProperty = new DateTime(2017, 1, 1), Property3 = 5}; var a2 = new A {IntProperty = 10, DateTimeProperty = new DateTime(2017, 1, 1), Property3 = 8}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void PropertyInequality() { var date1 = new DateTime(2017, 1, 1); var date2 = new DateTime(2017, 1, 2); var a1 = new A {IntProperty = 10, DateTimeProperty = date1}; var a2 = new A {IntProperty = 8, DateTimeProperty = date2}; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("IntProperty", differences[0].MemberPath); Assert.AreEqual("10", differences[0].Value1); Assert.AreEqual("8", differences[0].Value2); Assert.AreEqual("DateTimeProperty", differences[1].MemberPath); // ReSharper disable once SpecifyACultureInStringConversionExplicitly Assert.AreEqual(date1.ToString(), differences[1].Value1); // ReSharper disable once SpecifyACultureInStringConversionExplicitly Assert.AreEqual(date2.ToString(), differences[1].Value2); } [Test] public void ReadOnlyPropertyEquality() { var a1 = new A(1.99); var a2 = new A(1.99); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void ReadOnlyPropertyInequality() { var a1 = new A(1.99); var a2 = new A(0.89); var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ReadOnlyProperty", differences.First().MemberPath); Assert.AreEqual("1.99", differences.First().Value1); Assert.AreEqual("0.89", differences.First().Value2); } [Test] public void ProtectedProperty() { var a1 = new A(true); var a2 = new A(false); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void FieldEquality() { var a1 = new A {Field = 9}; var a2 = new A {Field = 9}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void FieldInequality() { var a1 = new A {Field = 10}; var a2 = new A {Field = 8}; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("Field", differences.First().MemberPath); Assert.AreEqual("10", differences.First().Value1); Assert.AreEqual("8", differences.First().Value2); } [Test] public void ReadOnlyFieldEquality() { var a1 = new A("Str1"); var a2 = new A("Str1"); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void ReadOnlyFieldInequality() { var a1 = new A("Str1"); var a2 = new A("Str2"); var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ReadOnlyField", differences.First().MemberPath); Assert.AreEqual("Str1", differences.First().Value1); Assert.AreEqual("Str2", differences.First().Value2); } [Test] public void ProtectedField() { var a1 = new A(5); var a2 = new A(6); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void ClassPropertyEquality() { var a1 = new A {ClassB = new B {Property1 = "Str1"}}; var a2 = new A {ClassB = new B {Property1 = "Str1"}}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void ClassPropertyInequality() { var a1 = new A {ClassB = new B {Property1 = "Str1"}}; var a2 = new A {ClassB = new B {Property1 = "Str2"}}; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ClassB.Property1", differences.First().MemberPath); Assert.AreEqual("Str1", differences.First().Value1); Assert.AreEqual("Str2", differences.First().Value2); } [Test] public void ClassPropertyInequalityFirstNull() { var a1 = new A(); var a2 = new A {ClassB = new B {Property1 = "Str2"}}; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ClassB", differences.First().MemberPath); Assert.AreEqual("", differences.First().Value1); Assert.AreEqual(a2.ClassB.ToString(), differences.First().Value2); } [Test] public void ClassPropertyInequalitySecondNull() { var a1 = new A {ClassB = new B {Property1 = "Str2"}}; var a2 = new A(); var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ClassB", differences.First().MemberPath); Assert.AreEqual(a1.ClassB.ToString(), differences.First().Value1); Assert.AreEqual("", differences.First().Value2); } [Test] public void NoRecursiveComparison() { var a1 = new A {ClassB = new B {Property1 = "Str1"}}; var a2 = new A {ClassB = new B {Property1 = "Str2"}}; var comparer = new Comparer(new ComparisonSettings {RecursiveComparison = false}); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void InterfacePropertyEquality() { var a1 = new A {IntefaceProperty = new TestInterfaceImplementation1 {Property = "Str1"}}; var a2 = new A { IntefaceProperty = new TestInterfaceImplementation2 {Property = "Str1", AnotherProperty = 50} }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void InterfacePropertyInequality() { var a1 = new A {IntefaceProperty = new TestInterfaceImplementation1 {Property = "Str1"}}; var a2 = new A { IntefaceProperty = new TestInterfaceImplementation2 {Property = "Str2", AnotherProperty = 50} }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("IntefaceProperty.Property", differences.First().MemberPath); Assert.AreEqual("Str1", differences.First().Value1); Assert.AreEqual("Str2", differences.First().Value2); } [Test] public void StructPropertyEquality() { var a1 = new A {StructProperty = new TestStruct {FieldA = "FA", FieldB = "FB"}}; var a2 = new A {StructProperty = new TestStruct {FieldA = "FA", FieldB = "FB"}}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void StructPropertyInequality() { var a1 = new A {StructProperty = new TestStruct {FieldA = "FA", FieldB = "FB"}}; var a2 = new A {StructProperty = new TestStruct {FieldA = "FA", FieldB = "FBB"}}; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("StructProperty.FieldB", differences.First().MemberPath); Assert.AreEqual("FB", differences.First().Value1); Assert.AreEqual("FBB", differences.First().Value2); } [Test] public void EnumPropertyEquality() { var a1 = new A {EnumProperty = TestEnum.Value1}; var a2 = new A {EnumProperty = TestEnum.Value1}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void EnumPropertyInequality() { var a1 = new A {EnumProperty = TestEnum.Value1}; var a2 = new A {EnumProperty = TestEnum.Value2}; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("EnumProperty", differences.First().MemberPath); Assert.AreEqual("Value1", differences.First().Value1); Assert.AreEqual("Value2", differences.First().Value2); } [Test] public void SetDefaultComparer() { var a1 = new A {TestProperty1 = "ABC", Field = 5}; var a2 = new A {TestProperty1 = "BCD", Field = 6}; var comparer = new Comparer(); var valueComparer = Substitute.For(); valueComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.SetDefaultComparer(valueComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); valueComparer.Received().Compare(Arg.Any(), Arg.Any(), Arg.Any()); } [Test] public void SetDefaultComparerNullException() { var comparer = new Comparer(); Assert.Throws(() => comparer.SetDefaultComparer(null)); } [Test] public void InheritedAndBaseClassInequality() { var a1 = new A {ClassB = new B {Property1 = "Str1"}}; var a2 = new A {ClassB = new InheritedFromB {Property1 = "Str2", NewProperty = "SomeValue"}}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("ClassB.Property1", differences.First().MemberPath); Assert.AreEqual("Str1", differences.First().Value1); Assert.AreEqual("Str2", differences.First().Value2); } [Test] public void InheritedAndBaseClassEquality() { var a1 = new A {ClassB = new B {Property1 = "Str1"}}; var a2 = new A {ClassB = new InheritedFromB {Property1 = "Str1", NewProperty = "SomeValue"}}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [TestCase(FlagsEnum.Flag1 | FlagsEnum.Flag2, FlagsEnum.Flag1 | FlagsEnum.Flag3)] [TestCase(FlagsEnum.Flag2, FlagsEnum.Flag3)] [TestCase(FlagsEnum.Flag1, FlagsEnum.Flag1 | FlagsEnum.Flag2)] public void FlagsInequality(FlagsEnum flags1, FlagsEnum flags2) { var a1 = new A {Flags = flags1}; var a2 = new A {Flags = flags2}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("Flags", differences.First().MemberPath); Assert.AreEqual(flags1.ToString(), differences.First().Value1); Assert.AreEqual(flags2.ToString(), differences.First().Value2); } [TestCase(FlagsEnum.Flag1 | FlagsEnum.Flag2, FlagsEnum.Flag1 | FlagsEnum.Flag2)] [TestCase(FlagsEnum.Flag2, FlagsEnum.Flag2)] public void FlagsEquality(FlagsEnum flags1, FlagsEnum flags2) { var a1 = new A {Flags = flags1}; var a2 = new A {Flags = flags2}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void TypePropertyEquality() { var a1 = new A {TypeProperty = typeof(string)}; var a2 = new A {TypeProperty = typeof(string)}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void TypePropertyInequality() { var a1 = new A {TypeProperty = typeof(string)}; var a2 = new A {TypeProperty = typeof(int)}; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("TypeProperty", differences.First().MemberPath); } [Test] public void TimeSpanEquality() { var a1 = new TimeSpan(123456789); var a2 = new TimeSpan(123456789); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void TimeSpanInequality() { var a1 = new TimeSpan(123456789); var a2 = new TimeSpan(123456788); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual(string.Empty, differences.First().MemberPath); } [Test] public void GuidEquality() { var a1 = new Guid("01234567890123456789012345678912"); var a2 = new Guid("01234567890123456789012345678912"); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void GuidInequality() { var a1 = new Guid("01234567890123456789012345678912"); var a2 = new Guid("01234567890123456789012345678913"); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual(string.Empty, differences.First().MemberPath); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_CompilerGeneratedObjectsTests.cs ================================================ using System.Linq; using NUnit.Framework; using NSubstitute; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerCompilerGeneratedObjectComparerObjectsTests { [Test] public void DifferentValues() { dynamic a1 = new { Field1 = "A", Field2 = 5, Field3 = true }; dynamic a2 = new { Field1 = "B", Field2 = 8, Field3 = false }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "8")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field3" && d.Value1 == "True" && d.Value2 == "False")); } [Test] public void MissedFields() { dynamic a1 = new { Field1 = "A", Field2 = 5 }; dynamic a2 = new { Field1 = "B", Field2 = 8, Field3 = false }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "8")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject && d.MemberPath == "Field3" && d.Value2 == "False")); } [Test] public void MissedFieldsAndUseDefaults() { dynamic a1 = new { Field1 = "A", Field2 = 5 }; dynamic a2 = new { Field1 = "B", Field3 = false, Field4 = "S" }; var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "0")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.MemberPath == "Field4" && d.Value2 == "S")); } [Test] public void Hierarchy() { dynamic a1Sub1 = new { FieldSub1 = 10 }; dynamic a1 = new { Field1 = a1Sub1 }; dynamic a2Sub1 = new { FieldSub1 = 8 }; dynamic a2 = new { Field1 = a2Sub1 }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1.FieldSub1" && d.Value1 == "10" && d.Value2 == "8")); } [Test] public void DifferentTypes() { dynamic a1 = new { Field1 = "A", Field2 = 5 }; dynamic a2 = new { Field1 = 5, Field2 = "5" }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "5" && d.DifferenceType == DifferenceTypes.TypeMismatch)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "5" && d.DifferenceType == DifferenceTypes.TypeMismatch)); } [Test] public void NullsAreEqual() { dynamic a1 = new { Field1 = (object)null }; dynamic a2 = new { Field1 = (object)null }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void NullAndMissedMemberAreNotEqual() { dynamic a1 = new { Field1 = (object)null }; dynamic a2 = new { Field2 = (object)null }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject)); } [Test] public void NullValues() { dynamic a1 = new { Field1 = "A", Field2 = (object)null }; dynamic a2 = new { Field1 = (object)null, Field2 = "B" }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == "A" && d.DifferenceType == DifferenceTypes.ValueMismatch)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.Value2 == "B" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void ComparerOverrideWhenEqual() { dynamic a1 = new { Field1 = "A" }; dynamic a2 = new { Field1 = " A " }; var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); var comparer = new Comparer(); comparer.AddComparerOverride("Field1", stringComparer); var isEqual = comparer.Compare((object)a1, (object)a2); Assert.IsTrue(isEqual); stringComparer.Received().Compare("A", " A ", Arg.Any()); } [Test] public void ComparerOverrideWhenNotEqual() { dynamic a1 = new { Field1 = "A" }; dynamic a2 = new { Field1 = "B" }; var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); stringComparer.ToString(Arg.Any()).Returns(callInfo => callInfo.Arg()?.ToString()); var comparer = new Comparer(); comparer.AddComparerOverride("Field1", stringComparer); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); stringComparer.Received().Compare("A", "B", Arg.Any()); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void ComparerOverrideWhenNullAndValueType() { dynamic a1 = new { Field1 = (object)null }; dynamic a2 = new { Field1 = 5 }; var comparer = new Comparer(); var intComparer = Substitute.For(); intComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); intComparer.ToString(5).Returns("5"); comparer.AddComparerOverride(intComparer); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == string.Empty && d.Value2 == "5" && d.DifferenceType == DifferenceTypes.TypeMismatch)); } [Test] public void UseDefaultValuesWhenSubclassNotSpecified() { dynamic a1 = new { Field1 = new { SubField1 = 0, SubField2 = (object) null, SubField3 = 0.0 } }; dynamic a2 = new {}; var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); var isEqual = comparer.Compare((object)a1, (object)a2); Assert.IsTrue(isEqual); } [Test] public void DifferenceWhenSubclassNotSpecified() { dynamic a1 = new { Field1 = new { SubField1 = 0, SubField2 = (object)null, SubField3 = 0.0 } }; dynamic a2 = new { }; var comparer = new Comparer(); var isEqual = comparer.Compare((object)a1, (object)a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_DynamicObjectsTests.cs ================================================ using System.Linq; using NUnit.Framework; using System.Collections.Generic; using System.Dynamic; using NSubstitute; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerDynamicObjectsTests { private class DynamicDictionary : DynamicObject { // ReSharper disable once UnusedMember.Local public int IntProperty { get; set; } private readonly Dictionary _dictionary = new Dictionary(); public override bool TryGetMember(GetMemberBinder binder, out object result) { var name = binder.Name; return _dictionary.TryGetValue(name, out result); } public override bool TrySetMember(SetMemberBinder binder, object value) { _dictionary[binder.Name] = value; return true; } public override IEnumerable GetDynamicMemberNames() { return _dictionary.Keys; } } [Test] public void DifferentValues() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; a1.Field2 = 5; a1.Field3 = true; dynamic a2 = new DynamicDictionary(); a2.Field1 = "B"; a2.Field2 = 8; a2.Field3 = false; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "8")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field3" && d.Value1 == "True" && d.Value2 == "False")); } [Test] public void MissedFields() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; a1.Field2 = 5; dynamic a2 = new DynamicDictionary(); a2.Field1 = "B"; a2.Field3 = false; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject && d.MemberPath == "Field2" && d.Value1 == "5")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject && d.MemberPath == "Field3" && d.Value2 == "False")); } [Test] public void MissedFieldsAndUseDefaults() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; a1.Field2 = 5; dynamic a2 = new DynamicDictionary(); a2.Field1 = "B"; a2.Field3 = false; a2.Field4 = "S"; var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "0")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.MemberPath == "Field4" && d.Value2 == "S")); } [Test] public void Hierarchy() { dynamic a1Sub1 = new DynamicDictionary(); a1Sub1.Field1 = 10; dynamic a1 = new DynamicDictionary(); a1.FieldSub1 = a1Sub1; dynamic a2Sub1 = new DynamicDictionary(); a2Sub1.Field1 = 8; dynamic a2 = new DynamicDictionary(); a2.FieldSub1 = a2Sub1; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "FieldSub1.Field1" && d.Value1 == "10" && d.Value2 == "8")); } [Test] public void DifferentTypes() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; a1.Field2 = 5; dynamic a2 = new DynamicDictionary(); a2.Field1 = 5; a2.Field2 = "5"; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.TypeMismatch)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.DifferenceType == DifferenceTypes.TypeMismatch)); } [Test] public void NullsAreEqual() { dynamic a1 = new DynamicDictionary(); a1.Field1 = null; dynamic a2 = new DynamicDictionary(); a2.Field1 = null; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void NullAndMissedMemberAreNotEqual() { dynamic a1 = new DynamicDictionary(); a1.Field1 = null; dynamic a2 = new DynamicDictionary(); a2.Field2 = null; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject)); } [Test] public void NullValues() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; a1.Field2 = null; dynamic a2 = new DynamicDictionary(); a2.Field1 = null; a2.Field2 = "B"; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == "A" && d.DifferenceType == DifferenceTypes.ValueMismatch)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.Value2 == "B" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void ComparerOverrideWhenEqual() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; dynamic a2 = new DynamicDictionary(); a2.Field1 = " A "; var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); var comparer = new Comparer(); comparer.AddComparerOverride("Field1", stringComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); stringComparer.Received().Compare("A", " A ", Arg.Any()); } [Test] public void ComparerOverrideWhenNotEqual() { dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; dynamic a2 = new DynamicDictionary(); a2.Field1 = "B"; var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); stringComparer.ToString(Arg.Any()).Returns(callInfo => callInfo.Arg()); var comparer = new Comparer(); comparer.AddComparerOverride("Field1", stringComparer); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); stringComparer.Received().Compare("A", "B", Arg.Any()); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void ComparerOverrideWhenNullAndValueType() { dynamic a1 = new DynamicDictionary(); a1.Field1 = null; dynamic a2 = new DynamicDictionary(); a2.Field1 = 5.0; var comparer = new Comparer(); var doubleComparer = Substitute.For(); doubleComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); doubleComparer.ToString(5.0).Returns("5.0"); comparer.AddComparerOverride(doubleComparer); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == string.Empty && d.Value2 == "5.0" && d.DifferenceType == DifferenceTypes.TypeMismatch)); } [Test] public void ComperaNonDynamicProperty() { dynamic a1 = new DynamicDictionary(); a1.IntProperty = 5; dynamic a2 = new DynamicDictionary(); a2.IntProperty = 7; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "IntProperty" && d.Value1 == "5" && d.Value2 == "7" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void UseDefaultValuesWhenSubclassNotSpecified() { dynamic a1 = new DynamicDictionary(); a1.Field1 = new DynamicDictionary(); a1.Field1.SubField1 = 0; a1.Field1.SubField2 = null; a1.Field1.SubField3 = 0.0; dynamic a2 = new DynamicDictionary(); var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void DifferenceWhenSubclassNotSpecified() { dynamic a1 = new DynamicDictionary(); a1.Field1 = new DynamicDictionary(); a1.Field1.SubField1 = 0; a1.Field1.SubField2 = null; a1.Field1.SubField3 = 0.0; dynamic a2 = new DynamicDictionary(); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_ExpandoObjectsTests.cs ================================================ using System.Linq; using NUnit.Framework; using System.Collections.Generic; using System.Dynamic; using Newtonsoft.Json; using NSubstitute; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerExpandoObjectsTests { [Test] public void DifferentValues() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 5; a1.Field3 = true; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field2 = 8; a2.Field3 = false; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "8")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field3" && d.Value1 == "True" && d.Value2 == "False")); } [Test] public void MissedFields() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 5; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field3 = false; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject && d.MemberPath == "Field2" && d.Value1 == "5")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject && d.MemberPath == "Field3" && d.Value2 == "False")); } [Test] public void MissedFieldsAndUseDefaults() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 5; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field3 = false; a2.Field4 = "S"; var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(3, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.MemberPath == "Field2" && d.Value1 == "5" && d.Value2 == "0")); Assert.IsTrue(differences.Any(d => d.DifferenceType == DifferenceTypes.ValueMismatch && d.MemberPath == "Field4" && d.Value2 == "S")); } [Test] public void Hierarchy() { dynamic a1Sub1 = new ExpandoObject(); a1Sub1.Field1 = 10; dynamic a1 = new ExpandoObject(); a1.FieldSub1 = a1Sub1; dynamic a2Sub1 = new ExpandoObject(); a2Sub1.Field1 = 8; dynamic a2 = new ExpandoObject(); a2.FieldSub1 = a2Sub1; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "FieldSub1.Field1" && d.Value1 == "10" && d.Value2 == "8")); } [Test] public void DifferentTypes() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 5; dynamic a2 = new ExpandoObject(); a2.Field1 = 5; a2.Field2 = "5"; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.TypeMismatch)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.DifferenceType == DifferenceTypes.TypeMismatch)); } [Test] public void NullsAreEqual() { dynamic a1 = new ExpandoObject(); a1.Field1 = null; dynamic a2 = new ExpandoObject(); a2.Field1 = null; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void NullAndMissedMemberAreNotEqual() { dynamic a1 = new ExpandoObject(); a1.Field1 = null; dynamic a2 = new ExpandoObject(); a2.Field2 = null; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.DifferenceType == DifferenceTypes.MissedMemberInFirstObject)); } [Test] public void NullValues() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = null; dynamic a2 = new ExpandoObject(); a2.Field1 = null; a2.Field2 = "B"; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == "A" && d.DifferenceType == DifferenceTypes.ValueMismatch)); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field2" && d.Value2 == "B" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void ComparerOverrideWhenEqual() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; dynamic a2 = new ExpandoObject(); a2.Field1 = " A "; var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); var comparer = new Comparer(); comparer.AddComparerOverride("Field1", stringComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); stringComparer.Received().Compare("A", " A ", Arg.Any()); } [Test] public void ComparerOverrideWhenNotEqual() { dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); stringComparer.ToString(Arg.Any()).Returns(callInfo => callInfo.Arg()); var comparer = new Comparer(); comparer.AddComparerOverride("Field1", stringComparer); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); stringComparer.Received().Compare("A", "B", Arg.Any()); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == "A" && d.Value2 == "B" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void ComparerOverrideWhenNullAndValueType() { dynamic a1 = new ExpandoObject(); a1.Field1 = null; dynamic a2 = new ExpandoObject(); a2.Field1 = 5; var comparer = new Comparer(); var intComparer = Substitute.For(); intComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); intComparer.ToString(5).Returns("5"); comparer.AddComparerOverride(intComparer); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.Value1 == string.Empty && d.Value2 == "5" && d.DifferenceType == DifferenceTypes.TypeMismatch)); } [Test] public void UseDefaultValuesWhenSubclassNotSpecified() { dynamic a1 = new ExpandoObject(); a1.Field1 = new ExpandoObject(); a1.Field1.SubField1 = 0; a1.Field1.SubField2 = null; a1.Field1.SubField3 = 0.0; dynamic a2 = new ExpandoObject(); var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void DifferenceWhenSubclassNotSpecified() { dynamic a1 = new ExpandoObject(); a1.Field1 = new ExpandoObject(); a1.Field1.SubField1 = 0; a1.Field1.SubField2 = null; a1.Field1.SubField3 = 0.0; dynamic a2 = new ExpandoObject(); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Field1" && d.DifferenceType == DifferenceTypes.MissedMemberInSecondObject)); } [Test] public void ExpandoObjectWithCollections() { var comparer = new Comparer(new ComparisonSettings { RecursiveComparison = true }); dynamic a1 = JsonConvert.DeserializeObject( "{ \"Transaction\": [ { \"Name\": \"abc\", \"No\": 101 } ] }"); dynamic a2 = JsonConvert.DeserializeObject( "{ \"Transaction\": [ { \"Name\": \"abc\", \"No\": 102 } ] }"); var isEqual = comparer.Compare(a1, a2, out IEnumerable differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == "Transaction[0].No" && d.DifferenceType == DifferenceTypes.ValueMismatch)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_GenericEnumerableTests.cs ================================================ using System.Collections.ObjectModel; using System.Linq; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; using System.Collections.Generic; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerGenericEnumerableTests { [Test] public void ValueTypeArrayEquality() { var a1 = new A { IntArray = new[] { 1, 2 } }; var a2 = new A { IntArray = new[] { 1, 2 } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void PrimitiveTypeArrayInequalityCount() { var a1 = new A { IntArray = new[] { 1, 2 } }; var a2 = new A { IntArray = new[] { 1, 2, 3 } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntArray.Length", differences[0].MemberPath); Assert.AreEqual("2", differences[0].Value1); Assert.AreEqual("3", differences[0].Value2); } [Test] public void PrimitiveTypeArrayInequalityMember() { var a1 = new A { IntArray = new[] { 1, 2 } }; var a2 = new A { IntArray = new[] { 1, 3 } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("IntArray[1]", differences.First().MemberPath); Assert.AreEqual("2", differences.First().Value1); Assert.AreEqual("3", differences.First().Value2); } [Test] public void PrimitiveTypeArrayInequalityFirstNull() { var a1 = new A(); var a2 = new A { IntArray = new int[0] }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("IntArray", differences.First().MemberPath); Assert.AreEqual(string.Empty, differences.First().Value1); Assert.AreEqual(a2.IntArray.ToString(), differences.First().Value2); Assert.AreEqual(DifferenceTypes.ValueMismatch, differences.First().DifferenceType); } [Test] public void PrimitiveTypeArrayInequalitySecondNull() { var a1 = new A { IntArray = new int[0] }; var a2 = new A(); var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("IntArray", differences.First().MemberPath); Assert.AreEqual(a1.IntArray.ToString(), differences.First().Value1); Assert.AreEqual(string.Empty, differences.First().Value2); } [Test] public void ClassArrayEquality() { var a1 = new A { ArrayOfB = new[] { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { ArrayOfB = new[] { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void ClassArrayInequalityCount() { var a1 = new A { ArrayOfB = new[] { new B { Property1 = "Str1" } } }; var a2 = new A { ArrayOfB = new[] { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("ArrayOfB.Length", differences[0].MemberPath); Assert.AreEqual("1", differences[0].Value1); Assert.AreEqual("2", differences[0].Value2); } [Test] public void ClassArrayInequalityProperty() { var a1 = new A { ArrayOfB = new[] { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { ArrayOfB = new[] { new B { Property1 = "Str1" }, new B { Property1 = "Str3" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ArrayOfB[1].Property1", differences.First().MemberPath); Assert.AreEqual("Str2", differences.First().Value1); Assert.AreEqual("Str3", differences.First().Value2); } [Test] public void CollectionEquality() { var a1 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void CollectionInequalityCount() { var a1 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual(DifferenceTypes.NumberOfElementsMismatch, differences[0].DifferenceType); Assert.AreEqual("CollectionOfB", differences[0].MemberPath); Assert.AreEqual("2", differences[0].Value1); Assert.AreEqual("1", differences[0].Value2); } [Test] public void CollectionAndNullInequality() { var a1 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A(); var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("CollectionOfB", differences[0].MemberPath); Assert.AreEqual(a1.CollectionOfB.ToString(), differences[0].Value1); Assert.AreEqual(string.Empty, differences[0].Value2); } [Test] public void NullAndCollectionInequality() { var a1 = new A(); var a2 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("CollectionOfB", differences[0].MemberPath); Assert.AreEqual(string.Empty, differences[0].Value1); Assert.AreEqual(a2.CollectionOfB.ToString(), differences[0].Value2); } [Test] public void IgnoreAttributeComparisonEquality() { var a1 = new Parent(); a1.Child1.Add(new ParentChild(a1, "Child1")); a1.Child1.Add(new ParentChild(a1, "Child2")); var a2 = new Parent(); a2.Child1.Add(new ParentChild(a2, "Child1")); a2.Child1.Add(new ParentChild(a2, "Child2")); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IgnoreAttributeComparisonInEquality() { var a1 = new Parent(); a1.Child1.Add(new ParentChild(a1, "Child1")); a1.Child1.Add(new ParentChild(a1, "Child2")); var a2 = new Parent(); a2.Child1.Add(new ParentChild(a2, "Child1")); a2.Child1.Add(new ParentChild(a2, "Child3")); var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("Child1[1].Property1", differences.First().MemberPath); Assert.AreEqual("Child2", differences.First().Value1); Assert.AreEqual("Child3", differences.First().Value2); } [Test] public void IgnoreAttributeComparisonDeepEquality() { var a1 = new Parent(); a1.Child1.Add(new ParentChild(a1, "Child1", new ObservableCollection { new Child("p1", "p2"), new Child("p3", "p4") } )); a1.Child1.Add(new ParentChild(a1, "Child2", new ObservableCollection { new Child("p1", "p2"), new Child("p3", "p4") } )); var a2 = new Parent(); a2.Child1.Add(new ParentChild(a1, "Child1", new ObservableCollection { new Child("p1", "p2"), new Child("p3", "p4") } )); a2.Child1.Add(new ParentChild(a1, "Child2", new ObservableCollection { new Child("p1", "p2"), new Child("p3", "p5") } )); var comparer = new Comparer (); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IgnoreAttributeComparisonDeepInEquality() { var a1 = new Parent(); a1.Child1.Add(new ParentChild(a1, "Child1", new ObservableCollection { new Child("p1", "p2"), new Child("p3", "p4") } )); a1.Child1.Add(new ParentChild(a1, "Child2", new ObservableCollection () { new Child("p1", "p2"), new Child("p3", "p4") } )); var a2 = new Parent(); a2.Child1.Add(new ParentChild(a1, "Child1", new ObservableCollection { new Child("p1", "p2"), new Child("p3", "p4") } )); a2.Child1.Add(new ParentChild(a1, "Child2", new ObservableCollection { new Child("p1", "p2"), new Child("p5", "p6") } )); var comparer = new Comparer (); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("Child1[1].Children[1].Property1", differences.First().MemberPath); Assert.AreEqual("p3", differences.First().Value1); Assert.AreEqual("p5", differences.First().Value2); } [Test] public void CollectionInequalityProperty() { var a1 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { CollectionOfB = new Collection { new B { Property1 = "Str1" }, new B { Property1 = "Str3" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("CollectionOfB[1].Property1", differences.First().MemberPath); Assert.AreEqual("Str2", differences.First().Value1); Assert.AreEqual("Str3", differences.First().Value2); } [Test] public void ClassImplementsCollectionEquality() { var a1 = new A { ClassImplementsCollectionOfB = new CollectionOfB { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { ClassImplementsCollectionOfB = new CollectionOfB { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void ClassImplementsCollectionInequalityCount() { var a1 = new A { ClassImplementsCollectionOfB = new CollectionOfB { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { ClassImplementsCollectionOfB = new CollectionOfB { new B { Property1 = "Str1" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual(DifferenceTypes.NumberOfElementsMismatch, differences[0].DifferenceType); Assert.AreEqual("ClassImplementsCollectionOfB", differences[0].MemberPath); Assert.AreEqual("2", differences[0].Value1); Assert.AreEqual("1", differences[0].Value2); } [Test] public void ClassImplementsCollectionInequalityProperty() { var a1 = new A { ClassImplementsCollectionOfB = new CollectionOfB { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { ClassImplementsCollectionOfB = new CollectionOfB { new B { Property1 = "Str1" }, new B { Property1 = "Str3" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ClassImplementsCollectionOfB[1].Property1", differences.First().MemberPath); Assert.AreEqual("Str2", differences.First().Value1); Assert.AreEqual("Str3", differences.First().Value2); } [Test] public void NullAndEmptyComparisonGenericInequality() { var a1 = new A { ListOfB = new List() }; var a2 = new A(); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ListOfB", differences.First().MemberPath); Assert.AreEqual(a1.ListOfB.ToString(), differences.First().Value1); Assert.AreEqual(string.Empty, differences.First().Value2); } [Test] public void NullAndEmptyComparisonGenericEquality() { var a1 = new A { ListOfB = new List() }; var a2 = new A(); var comparer = new Comparer(new ComparisonSettings { EmptyAndNullEnumerablesEqual = true }); var isEqual = comparer.Compare(a1, a2, out var differences); Assert.IsTrue(isEqual); CollectionAssert.IsEmpty(differences); } [TestCase(FlagsEnum.Flag1 | FlagsEnum.Flag2, FlagsEnum.Flag1 | FlagsEnum.Flag3)] [TestCase(FlagsEnum.Flag2, FlagsEnum.Flag3)] [TestCase(FlagsEnum.Flag1, FlagsEnum.Flag1 | FlagsEnum.Flag2)] public void FlagsInequality(FlagsEnum flags1, FlagsEnum flags2) { var a1 = new A { Flags = flags1 }; var a2 = new A { Flags = flags2 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("Flags", differences.First().MemberPath); Assert.AreEqual(flags1.ToString(), differences.First().Value1); Assert.AreEqual(flags2.ToString(), differences.First().Value2); } [TestCase(FlagsEnum.Flag1 | FlagsEnum.Flag2, FlagsEnum.Flag1 | FlagsEnum.Flag2)] [TestCase(FlagsEnum.Flag2, FlagsEnum.Flag2)] public void FlagsEquality(FlagsEnum flags1, FlagsEnum flags2) { var a1 = new A { Flags = flags1 }; var a2 = new A { Flags = flags2 }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void CollectionOfBCountInequality1() { var a1 = new A { EnumerableOfB = new[] { new B { Property1 = "B1" } } }; var a2 = new A { EnumerableOfB = new[] { new B { Property1 = "B1" }, new B { Property1 = "B2" } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("EnumerableOfB", differences.First().MemberPath); Assert.AreEqual(DifferenceTypes.NumberOfElementsMismatch, differences.First().DifferenceType); Assert.AreEqual("1", differences.First().Value1); Assert.AreEqual("2", differences.First().Value2); } [Test] public void CollectionOfBCountInequality2() { var a1 = new A { EnumerableOfB = new[] { new B { Property1 = "B1" } } }; var a2 = new A { EnumerableOfB = new B[0] }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("EnumerableOfB", differences.First().MemberPath); Assert.AreEqual(DifferenceTypes.NumberOfElementsMismatch, differences.First().DifferenceType); Assert.AreEqual("1", differences.First().Value1); Assert.AreEqual("0", differences.First().Value2); } [Test] public void HashSetEqualitySameOrder() { var a1 = new HashSet { "a", "b" }; var a2 = new HashSet { "a", "b" }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void HashSetEqualityDifferentOrder() { var a1 = new HashSet { "a", "b" }; var a2 = new HashSet { "b", "a" }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void HashSetInequalityDifferentElements() { var a1 = new HashSet { "a", "b" }; var a2 = new HashSet { "a", "c" }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == string.Empty && d.DifferenceType == DifferenceTypes.MissedElementInFirstObject && d.Value2 == "c")); Assert.IsTrue(differences.Any( d => d.MemberPath == string.Empty && d.DifferenceType == DifferenceTypes.MissedElementInSecondObject && d.Value1 == "b")); } [Test] public void HashSetInequalityDifferentNumberOfElements() { var a1 = new HashSet { "a", "b" }; var a2 = new HashSet { "a", "b", "c" }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == string.Empty && d.DifferenceType == DifferenceTypes.MissedElementInFirstObject && d.Value2 == "c")); } [Test] public void HashSetAndNullInequality() { var a = new HashSet { "a", "b" }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a, null, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.IsTrue(differences.Any( d => d.MemberPath == string.Empty && d.DifferenceType == DifferenceTypes.ValueMismatch)); } [Test] public void IgnoreCapacityForLists() { var a1 = new A { ListOfB = new List { new B { Property1 = "str2" }, new B { Property1 = "str2" } } }; var a2 = new A { ListOfB = new List { new B { Property1 = "str2" }, new B { Property1 = "str2" } } }; a1.ListOfB.TrimExcess(); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void CompareAsIList() { var list1 = new List { 1, 2 }; var list2 = new List { 1 }; var comparer = new Comparer>(); var differences = comparer.CalculateDifferences(list1, list2).ToList(); Assert.AreEqual(1, differences.Count); Assert.AreEqual(DifferenceTypes.NumberOfElementsMismatch, differences.First().DifferenceType); Assert.AreEqual("2", differences.First().Value1); Assert.AreEqual("1", differences.First().Value2); } [Test] public void DictionaryEqualitySameOrder() { var a1 = new Dictionary { { 1, "One" }, { 2, "Two" } }; var a2 = new Dictionary { { 1, "One" }, { 2, "Two" } }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void DictionaryInequalityDifferentOrder() { var a1 = new Dictionary { { 1, "One" }, { 2, "Two" } }; var a2 = new Dictionary { { 2, "Two" }, { 1, "One" } }; var comparer = new Comparer>(); var isEqual = comparer.Compare(a1, a2); Assert.IsFalse(isEqual); } [Test] public void DictionaryInequalityDifferentNumberOfElements() { var a1 = new Dictionary { { 1, "One" }, { 2, "Two" } }; var a2 = new Dictionary { { 1, "One" }, { 2, "Two" }, { 3, "Three" } }; var comparer = new Comparer>(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); Assert.AreEqual(1, differences.Count); Assert.AreEqual(DifferenceTypes.NumberOfElementsMismatch, differences.First().DifferenceType); } [Test] public void DictionaryInequalityDifferentValue() { var a1 = new Dictionary { { 1, "One" }, { 2, "Two" } }; var a2 = new Dictionary { { 1, "One" }, { 2, "Two!" } }; var comparer = new Comparer>(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); Assert.AreEqual(1, differences.Count); Assert.AreEqual(DifferenceTypes.ValueMismatch, differences.First().DifferenceType); Assert.AreEqual("Two", differences.First().Value1); Assert.AreEqual("Two!", differences.First().Value2); Assert.AreEqual("[1].Value", differences.First().MemberPath); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_IPEndPointTests.cs ================================================ using System.Linq; using System.Net; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class Comparer_IPEndPointTests { [Test] public void Equality() { var a1 = new IPEndPoint(50, 20); var a2 = new IPEndPoint(50, 20); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void Inequality() { var a1 = new IPEndPoint(50, 20); var a2 = new IPEndPoint(52, 21); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(2, differences.Count); Assert.IsTrue(differences.Any(d => d.MemberPath == "Address.Address" && d.Value1 == "50" && d.Value2 == "52")); Assert.IsTrue(differences.Any(d => d.MemberPath == "Port" && d.Value1 == "20" && d.Value2 == "21")); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_Issue24Tests.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using NSubstitute; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class Comparer_Issue24Tests { class MyComparersFactory : ComparersFactory { public override IComparer GetObjectsComparer(ComparisonSettings settings = null, BaseComparer parentComparer = null) { IComparer comparer = base.GetObjectsComparer(settings, parentComparer); if (parentComparer == null) { comparer.AddComparerOverride(typeof(string), new IgnoreCaseStringsValueComparer()); } return comparer; } } class TestClassA { public string A { get; set; } } class TestClassB { public string B { get; set; } public TestClassA ClassA { get; set; } } [Test] public void OverrideString() { var b1 = new TestClassB { B = "B", ClassA = new TestClassA { A = "A" } }; var b2 = new TestClassB { B = "b", ClassA = new TestClassA { A = "a" } }; var settings = new ComparisonSettings(); var factory = new MyComparersFactory(); var comparer = factory.GetObjectsComparer(settings); var isEqual = comparer.Compare(b1, b2); Assert.IsTrue(isEqual); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_MultidimensionalArraysTests.cs ================================================ using System.Linq; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerMultidimensionalArraysTests { [Test] public void IntOfIntInequality1() { var a1 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 } } }; var a2 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 3 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntOfInt[0][1]", differences[0].MemberPath); Assert.AreEqual("2", differences[0].Value1); Assert.AreEqual("3", differences[0].Value2); } [Test] public void IntOfIntInequality2() { var a1 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 }, new[] { 3, 4 } } }; var a2 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 2, 2 }, new[] { 3, 5 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(2, differences.Count); Assert.AreEqual("IntOfInt[0][0]", differences[0].MemberPath); Assert.AreEqual("1", differences[0].Value1); Assert.AreEqual("2", differences[0].Value2); Assert.AreEqual("IntOfInt[1][1]", differences[1].MemberPath); Assert.AreEqual("4", differences[1].Value1); Assert.AreEqual("5", differences[1].Value2); } [Test] public void IntOfIntInequality3() { var a1 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 } } }; var a2 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 2, 2 }, new[] { 3, 5 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntOfInt.Length", differences[0].MemberPath); Assert.AreEqual("1", differences[0].Value1); Assert.AreEqual("2", differences[0].Value2); } [Test] public void IntOfIntInequality4() { var a1 = new MultidimensionalArrays { IntOfInt = new int[0][] }; var a2 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 2, 2 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntOfInt.Length", differences[0].MemberPath); Assert.AreEqual("0", differences[0].Value1); Assert.AreEqual("1", differences[0].Value2); } [Test] public void IntOfIntInequality5() { var a1 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 }, new[] { 3, 5 } } }; var a2 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 }, new[] { 3, 5, 6 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntOfInt[1].Length", differences[0].MemberPath); Assert.AreEqual("2", differences[0].Value1); Assert.AreEqual("3", differences[0].Value2); } [Test] public void IntOfIntInequality6() { var a1 = new MultidimensionalArrays { IntOfInt = new int[0][] }; var a2 = new MultidimensionalArrays(); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntOfInt", differences[0].MemberPath); Assert.AreEqual(typeof(int[][]).FullName, differences[0].Value1); Assert.AreEqual(string.Empty, differences[0].Value2); } [Test] public void IntOfIntInequality7() { var a1 = new MultidimensionalArrays(); var a2 = new MultidimensionalArrays { IntOfInt = new int[0][] }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntOfInt", differences[0].MemberPath); Assert.AreEqual(string.Empty, differences[0].Value1); Assert.AreEqual(typeof(int[][]).FullName, differences[0].Value2); } [Test] public void IntOfIntEquality1() { var a1 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 }, new[] { 3, 5 } } }; var a2 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 }, new[] { 3, 5 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IntOfIntEquality2() { var a1 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 }, new int[0] } }; var a2 = new MultidimensionalArrays { IntOfInt = new[] { new[] { 1, 2 }, new int[0] } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IntOfIntEquality3() { var a1 = new MultidimensionalArrays { IntOfInt = new int[0][] }; var a2 = new MultidimensionalArrays { IntOfInt = new int[0][] }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IntOfIntEquality4() { var a1 = new MultidimensionalArrays { IntOfInt = new int[0][] }; var a2 = new MultidimensionalArrays(); var comparer = new Comparer(new ComparisonSettings { EmptyAndNullEnumerablesEqual = true }); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IntOfIntEquality5() { var a1 = new MultidimensionalArrays(); var a2 = new MultidimensionalArrays { IntOfInt = new int[0][] }; var comparer = new Comparer(new ComparisonSettings { EmptyAndNullEnumerablesEqual = true }); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IntIntInequality1() { var a1 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 } } }; var a2 = new MultidimensionalArrays { IntInt = new[,] { { 1, 3 }, { 1, 3 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntInt.Dimension0", differences[0].MemberPath); Assert.AreEqual("1", differences[0].Value1); Assert.AreEqual("2", differences[0].Value2); } [Test] public void IntIntInequality2() { var a1 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 }, { 1, 3 } } }; var a2 = new MultidimensionalArrays { IntInt = new[,] { { 1, 3, 4 }, { 1, 3, 8 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntInt.Dimension1", differences[0].MemberPath); Assert.AreEqual("2", differences[0].Value1); Assert.AreEqual("3", differences[0].Value2); } [Test] public void IntIntInequality3() { var a1 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 } } }; var a2 = new MultidimensionalArrays { IntInt = new[,] { { 1, 3 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntInt[0,1]", differences[0].MemberPath); Assert.AreEqual("2", differences[0].Value1); Assert.AreEqual("3", differences[0].Value2); } [Test] public void IntIntInequality4() { var a1 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 }, { 3, 4 } } }; var a2 = new MultidimensionalArrays { IntInt = new[,] { { 0, 2 }, { 3, 4 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntInt[0,0]", differences[0].MemberPath); Assert.AreEqual("1", differences[0].Value1); Assert.AreEqual("0", differences[0].Value2); } [Test] public void IntIntInequality5() { var a1 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 }, { 3, 0 } } }; var a2 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 }, { 3, 4 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntInt[1,1]", differences[0].MemberPath); Assert.AreEqual("0", differences[0].Value1); Assert.AreEqual("4", differences[0].Value2); } [Test] public void IntIntInequality6() { var a1 = new MultidimensionalArrays { IntInt = null }; var a2 = new MultidimensionalArrays { IntInt = new int[0, 0] }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntInt", differences[0].MemberPath); Assert.AreEqual(string.Empty, differences[0].Value1); Assert.AreEqual(typeof(int[,]).FullName, differences[0].Value2); } [Test] public void IntIntInequality7() { var a1 = new MultidimensionalArrays { IntInt = new int[0, 0] }; var a2 = new MultidimensionalArrays { IntInt = null }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("IntInt", differences[0].MemberPath); Assert.AreEqual(typeof(int[,]).FullName, differences[0].Value1); Assert.AreEqual(string.Empty, differences[0].Value2); } [Test] public void IntIntEquality1() { var a1 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 }, { 3, 4 } } }; var a2 = new MultidimensionalArrays { IntInt = new[,] { { 1, 2 }, { 3, 4 } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IntIntEquality2() { var a1 = new MultidimensionalArrays { IntInt = null }; var a2 = new MultidimensionalArrays { IntInt = new int[0, 0] }; var comparer = new Comparer(new ComparisonSettings { EmptyAndNullEnumerablesEqual = true }); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IntIntEquality3() { var a1 = new MultidimensionalArrays { IntInt = new int[0, 0] }; var a2 = new MultidimensionalArrays { IntInt = null }; var comparer = new Comparer(new ComparisonSettings { EmptyAndNullEnumerablesEqual = true }); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_NonGenericEnumerableTests.cs ================================================ using System.Collections; using System.Linq; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerNonGenericEnumerableTests { [Test] public void Equality() { var a1 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void InequalityCount() { var a1 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("NonGenericEnumerable", differences.First().MemberPath); Assert.AreEqual(DifferenceTypes.NumberOfElementsMismatch, differences.First().DifferenceType); Assert.AreEqual("2", differences.First().Value1); Assert.AreEqual("1", differences.First().Value2); } [Test] public void InequalityProperty() { var a1 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str3" } } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("NonGenericEnumerable[1].Property1", differences.First().MemberPath); Assert.AreEqual("Str2", differences.First().Value1); Assert.AreEqual("Str3", differences.First().Value2); } [Test] public void NullElementsEquality() { var a1 = new A { NonGenericEnumerable = new ArrayList { null } }; var a2 = new A { NonGenericEnumerable = new ArrayList { null } }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void NullAndNotNullElementsInequality() { var a1 = new A { NonGenericEnumerable = new ArrayList { null, "Str1" } }; var a2 = new A { NonGenericEnumerable = new ArrayList { "Str2", null } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); Assert.AreEqual(2, differences.Count); Assert.AreEqual("NonGenericEnumerable[0]", differences[0].MemberPath); Assert.AreEqual(string.Empty, differences[0].Value1); Assert.AreEqual("Str2", differences[0].Value2); Assert.AreEqual("NonGenericEnumerable[1]", differences[1].MemberPath); Assert.AreEqual("Str1", differences[1].Value1); Assert.AreEqual(string.Empty, differences[1].Value2); } [Test] public void InequalityType() { var a1 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } } }; var a2 = new A { NonGenericEnumerable = new ArrayList { new B { Property1 = "Str1" }, "Str3" } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("NonGenericEnumerable[1]", differences.First().MemberPath); Assert.AreEqual("ObjectsComparer.Tests.TestClasses.B", differences.First().Value1); Assert.AreEqual("Str3", differences.First().Value2); } [Test] public void DerivedClassEquality() { var a1 = new A { NonGenericEnumerableImplementation = new EnumerableImplementation(new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } }) }; var a2 = new A { NonGenericEnumerableImplementation = new EnumerableImplementation(new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } }) }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void DerivedClassInequalityProperty() { var a1 = new A { NonGenericEnumerableImplementation = new EnumerableImplementation(new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } }) { Property1 = "Str3" } }; var a2 = new A { NonGenericEnumerableImplementation = new EnumerableImplementation(new ArrayList { new B { Property1 = "Str1" }, new B { Property1 = "Str2" } }) { Property1 = "Str4" } }; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("NonGenericEnumerableImplementation.Property1", differences.First().MemberPath); Assert.AreEqual("Str3", differences.First().Value1); Assert.AreEqual("Str4", differences.First().Value2); } [Test] public void NullAndEmptyInequality() { var a1 = new A { NonGenericEnumerable = new ArrayList() }; var a2 = new A(); var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("NonGenericEnumerable[]", differences.First().MemberPath); Assert.AreEqual("System.Collections.ArrayList", differences.First().Value1); Assert.AreEqual(string.Empty, differences.First().Value2); } [Test] public void NullAndEmptyEquality() { var a1 = new A { NonGenericEnumerable = new ArrayList() }; var a2 = new A(); var comparer = new Comparer(new ComparisonSettings { EmptyAndNullEnumerablesEqual = true }); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_OverridesTests.cs ================================================ using System.Linq; using System.Reflection; using NSubstitute; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class ComparerOverridesTests { [Test] public void OverrideStringComparisonWhenEqual() { var a1 = new A { TestProperty1 = "ABC", TestProperty2 = "ABC", ClassB = new B { Property1 = "Str1" } }; var a2 = new A { TestProperty1 = "BCD", TestProperty2 = "ABC", ClassB = new B { Property1 = "Str2" } }; var comparer = new Comparer(); var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.AddComparerOverride(stringComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); stringComparer.Received().Compare(Arg.Any(), Arg.Any(), Arg.Any()); } [Test] public void OverrideStringComparisonWhenNotEqual() { var a1 = new A { TestProperty1 = "ABC", TestProperty2 = "ABC", ClassB = new B { Property1 = "Str1" } }; var a2 = new A { TestProperty1 = "BCD", TestProperty2 = "ABC", ClassB = new B { Property1 = "Str1" } }; var comparer = new Comparer(); var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); stringComparer.ToString(Arg.Any()).Returns(info => (info.Arg() ?? string.Empty).ToString()); comparer.AddComparerOverride(typeof(string), stringComparer); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.IsTrue(differences.Any(d => d.MemberPath == "TestProperty1" && d.Value1 == "ABC" && d.Value2 == "BCD")); Assert.IsTrue(differences.Any(d => d.MemberPath == "TestProperty2" && d.Value1 == "ABC" && d.Value2 == "ABC")); Assert.IsTrue(differences.Any(d => d.MemberPath == "ClassB.Property1" && d.Value1 == "Str1" && d.Value2 == "Str1")); stringComparer.Received().Compare(Arg.Any(), Arg.Any(), Arg.Any()); stringComparer.Received().ToString(Arg.Any()); } [Test] public void OverrideIntComparisonWhenNotEqual() { var a1 = new A { IntArray = new[] { 1, 2 } }; var a2 = new A { IntArray = new[] { 1, 3 } }; var comparer = new Comparer(); var stringComparer = Substitute.For(); stringComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(false); stringComparer.ToString(Arg.Any()).Returns(info => (info.Arg() ?? string.Empty).ToString()); comparer.AddComparerOverride(stringComparer); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.IsTrue(differences.Any(d => d.MemberPath == "IntArray[0]" && d.Value1 == "1" && d.Value2 == "1")); Assert.IsTrue(differences.Any(d => d.MemberPath == "IntArray[1]" && d.Value1 == "2" && d.Value2 == "3")); stringComparer.Received().Compare(Arg.Any(), Arg.Any(), Arg.Any()); stringComparer.Received().ToString(Arg.Any()); } [Test] public void OverrideIntComparisonWhenEqual() { var a1 = new A { IntArray = new[] { 1, 2 } }; var a2 = new A { IntArray = new[] { 1, 3 } }; var comparer = new Comparer(); var intComparer = Substitute.For(); intComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); intComparer.ToString(Arg.Any()).Returns(info => (info.Arg() ?? string.Empty).ToString()); comparer.AddComparerOverride(typeof(int), intComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); intComparer.Received().Compare(Arg.Any(), Arg.Any(), Arg.Any()); } [Test] public void OverridePropertyComparisonWhenEqual() { var a1 = new A { TestProperty1 = "ABC" }; var a2 = new A { TestProperty1 = "BCD" }; var comparer = new Comparer(); var valueComparer = Substitute.For(); valueComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.AddComparerOverride(() => a1.TestProperty1, valueComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); valueComparer.Received(1).Compare(Arg.Any(), Arg.Any(), Arg.Any()); } [Test] public void OverrideBClassComparerWhenEqual() { var a1 = new A { ClassB = new B { Property1 = "123-456-7898" } }; var a2 = new A { ClassB = new B { Property1 = "(123)-456-7898" } }; var valueComparer = CreateClassBComparerAsPhone(); var comparer = new Comparer(); comparer.AddComparerOverride(valueComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void OverrideBClassComparerWhenNotEqual() { var a1 = new A { ClassB = new B { Property1 = "123-456-7898" } }; var a2 = new A { ClassB = new B { Property1 = "(123)-456-7899" } }; var valueComparer = CreateClassBComparerAsPhone(); var comparer = new Comparer(); comparer.AddComparerOverride(valueComparer); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ClassB", differences[0].MemberPath); Assert.AreEqual("123-456-7898", differences[0].Value1); Assert.AreEqual("(123)-456-7899", differences[0].Value2); } [Test] public void OverrideBClassProperty1ComparerWhenEqual() { var a1 = new A { ClassB = new B { Property1 = "123-456-7898" } }; var a2 = new A { ClassB = new B { Property1 = "(123)-456-7898" } }; var valueComparer = CreatePhoneComparer(); var comparer = new Comparer(); comparer.AddComparerOverride(() => new B().Property1, valueComparer); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void OverrideBClassProperty1ComparerWhenNotEqual() { var a1 = new A { ClassB = new B { Property1 = "123-456-7898" } }; var a2 = new A { ClassB = new B { Property1 = "(123)-456-7899" } }; var valueComparer = CreatePhoneComparer(); var comparer = new Comparer(); comparer.AddComparerOverride(() => new B().Property1, valueComparer); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ClassB.Property1", differences[0].MemberPath); Assert.AreEqual("123-456-7898", differences[0].Value1); Assert.AreEqual("(123)-456-7899", differences[0].Value2); } [Test] public void OverrideBClassProperty1ComparerWithFunction() { var a1 = new A { ClassB = new B { Property1 = "123-456-7898" } }; var a2 = new A { ClassB = new B { Property1 = "(123)-456-7898" } }; var comparer = new Comparer(); comparer.AddComparerOverride( () => new B().Property1, (phone1, phone2, parentSettings) => ExtractDigits(phone1) == ExtractDigits(phone2), s => s); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void OverrideBClassProperty1ComparerWithFunctionAndDefaultToString() { var a1 = new A { ClassB = new B { Property1 = "123-456-7898" } }; var a2 = new A { ClassB = new B { Property1 = "(123)-456-7899" } }; var comparer = new Comparer(); comparer.AddComparerOverride( () => new B().Property1, (phone1, phone2, parentSettings) => ExtractDigits(phone1) == ExtractDigits(phone2)); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual("ClassB.Property1", differences[0].MemberPath); Assert.AreEqual("123-456-7898", differences[0].Value1); Assert.AreEqual("(123)-456-7899", differences[0].Value2); } [Test] public void OverrideBClassProperty1ByMemberInfo() { var a1 = new A { ClassB = new B { Property1 = "S1" } }; var a2 = new A { ClassB = new B { Property1 = "S2" } }; var comparer = new Comparer(); var valueComparer = Substitute.For(); valueComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.AddComparerOverride( typeof(B).GetTypeInfo().GetMember("Property1").First(), valueComparer); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsEmpty(differences); valueComparer.Received().Compare("S1", "S2", Arg.Any()); } [Test] public void OverrideByName() { var a1 = new A { ClassB = new B { Property1 = "123-456-7899" } }; var a2 = new A { ClassB = new B { Property1 = "(123)-456-7899" } }; var comparer = new Comparer(); var phoneComparer = Substitute.For(); phoneComparer.Compare("123-456-7899", "(123)-456-7899", Arg.Any()).Returns(true); comparer.AddComparerOverride("Property1", phoneComparer); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsEmpty(differences); phoneComparer.Received().Compare("123-456-7899", "(123)-456-7899", Arg.Any()); } [Test] public void OverrideMemberHighestPriority() { var a1 = new A { ClassB = new B { Property1 = "S1" } }; var a2 = new A { ClassB = new B { Property1 = "S2" } }; var comparer = new Comparer(); var valueComparer1 = Substitute.For(); valueComparer1.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); var valueComparer2 = Substitute.For(); valueComparer2.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); var valueComparer3 = Substitute.For(); valueComparer3.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.AddComparerOverride(valueComparer1); comparer.AddComparerOverride(() => a1.ClassB.Property1, valueComparer2); comparer.AddComparerOverride("Property1", valueComparer3); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsEmpty(differences); valueComparer2.Received().Compare("S1", "S2", Arg.Any()); valueComparer1.DidNotReceive().Compare("S1", "S2", Arg.Any()); valueComparer3.DidNotReceive().Compare("S1", "S2", Arg.Any()); } [Test] public void OverrideMemberHigherPriorityThanByName() { var a1 = new A { ClassB = new B { Property1 = "S1" } }; var a2 = new A { ClassB = new B { Property1 = "S2" } }; var comparer = new Comparer(); var valueComparer1 = Substitute.For(); valueComparer1.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); var valueComparer2 = Substitute.For(); valueComparer2.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.AddComparerOverride(valueComparer1); comparer.AddComparerOverride(() => a1.ClassB.Property1, valueComparer1); comparer.AddComparerOverride("Property1", valueComparer2); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsEmpty(differences); valueComparer1.Received().Compare("S1", "S2", Arg.Any()); valueComparer2.DidNotReceive().Compare("S1", "S2", Arg.Any()); } [Test] public void OverrideTypeWithFilterAndByName() { var a1 = new A { ClassB = new B { Property1 = "S1" } }; var a2 = new A { ClassB = new B { Property1 = "S2" } }; var comparer = new Comparer(); var valueComparer1 = Substitute.For(); valueComparer1.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); var valueComparer2 = Substitute.For(); valueComparer2.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.AddComparerOverride(valueComparer1, memberInfo => memberInfo.Name != "Property1"); comparer.AddComparerOverride("Property1", valueComparer2); var differences = comparer.CalculateDifferences(a1, a2).ToList(); CollectionAssert.IsEmpty(differences); valueComparer1.DidNotReceive().Compare("S1", "S2", Arg.Any()); valueComparer2.Received().Compare("S1", "S2", Arg.Any()); } [Test] public void IgnoreByName() { var a1 = new A { TestProperty1 = "Str1", IntProperty = 5}; var a2 = new A { TestProperty1 = "Str2", IntProperty = 5 }; var comparer = new Comparer(); comparer.IgnoreMember("TestProperty1"); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IgnoreByType() { var a1 = new A { TestProperty1 = "Str1", IntProperty = 5 }; var a2 = new A { TestProperty1 = "Str2", IntProperty = 5 }; var comparer = new Comparer(); comparer.IgnoreMember(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void IgnoreByMember() { var a1 = new A { TestProperty1 = "Str1", IntProperty = 5 }; var a2 = new A { TestProperty1 = "Str2", IntProperty = 5 }; var comparer = new Comparer(); comparer.IgnoreMember(() => new A().TestProperty1); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void OverrideByMemberFilter() { var a1 = new A { TestProperty1 = "ABC" }; var a2 = new A { TestProperty1 = "ABC" }; var comparer = new Comparer(); var valueComparer = Substitute.For(); valueComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(true); comparer.AddComparerOverride(valueComparer, member => member.Name == "TestProperty1"); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); valueComparer.Received(1).Compare(Arg.Is("ABC"), Arg.Is("ABC"), Arg.Any()); } [Test] public void IgnoreByMemberFilter() { var a1 = new A { TestProperty1 = "ABC" }; var a2 = new A { TestProperty1 = "BCD" }; var comparer = new Comparer(); comparer.IgnoreMember(member => member.Name == "TestProperty1"); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } private IValueComparer CreateClassBComparerAsPhone() { var valueComparer = Substitute.For(); valueComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(callInfo => { var b1 = (B)callInfo.ArgAt(0); var b2 = (B)callInfo.ArgAt(1); return ExtractDigits(b1.Property1) == ExtractDigits(b2.Property1); }); valueComparer.ToString(Arg.Any()).Returns(callInfo => ((B)callInfo.Arg()).Property1); return valueComparer; } private IValueComparer CreatePhoneComparer() { var valueComparer = Substitute.For(); valueComparer.Compare(Arg.Any(), Arg.Any(), Arg.Any()).Returns(callInfo => { var s1 = (string)callInfo.ArgAt(0); var s2 = (string)callInfo.ArgAt(1); return ExtractDigits(s1) == ExtractDigits(s2); }); valueComparer.ToString(Arg.Any()).Returns(callInfo => (string)callInfo.Arg()); return valueComparer; } private string ExtractDigits(string str) { return string.Join(string.Empty, (str ?? string.Empty).ToCharArray().Where(char.IsDigit)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_StringBuilderTests.cs ================================================ using System.Linq; using NUnit.Framework; using System.Text; namespace ObjectsComparer.Tests { [TestFixture] public class Comparer_StringBuilderTests { [Test] public void StringBuilderEquality() { var a1 = new StringBuilder("abc"); var a2 = new StringBuilder("abc"); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void StringBuilderInequality() { var a1 = new StringBuilder("abc"); var a2 = new StringBuilder("abd"); var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual(string.Empty, differences.First().MemberPath); Assert.AreEqual("abc", differences.First().Value1); Assert.AreEqual("abd", differences.First().Value2); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Comparer_UriTests.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class Comparer_UriTests { public class TestClass { public IList Urls { get; } = new List(); } [Test] public void Equality() { var a1 = new { MyUri = new Uri("https://www.google.com/") }; var a2 = new { MyUri = new Uri("https://www.google.com/") }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); Assert.IsTrue(isEqual); } [Test] public void Inequality() { var a1 = new { MyUri = new Uri("https://www.google.com/") }; var a2 = new { MyUri = new Uri("https://www.yahoo.com/") }; var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2, out var differencesEnum); var differences = differencesEnum.ToList(); Assert.IsFalse(isEqual); CollectionAssert.IsNotEmpty(differences); Assert.AreEqual(1, differences.Count); Assert.AreEqual("MyUri", differences.First().MemberPath); } [Test] public void ListOfUris() { var a1 = new TestClass(); a1.Urls.Add(new Uri("https://Test.com")); var a2 = new TestClass(); a2.Urls.Add(new Uri("https://Test.com")); var comparer = new ObjectsComparer.Comparer(); // comparer.AddComparerOverride>(new ListOfUriComparer()); IEnumerable differences = new List(); comparer.Compare(a1, a2, out differences); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ComparersFactoryTests.cs ================================================ using System.Collections.Generic; using NSubstitute; using NUnit.Framework; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class ComparersFactoryTests { private IComparer _comparerB; private class CustomFactory : ComparersFactory { private readonly IComparer _comparerB; public CustomFactory(IComparer comparerB) { _comparerB = comparerB; } public override IComparer GetObjectsComparer(ComparisonSettings settings = null, BaseComparer parentComparer = null) { if (typeof(T) == typeof(B)) { return (IComparer)_comparerB; } return base.GetObjectsComparer(settings, parentComparer); } } [SetUp] public void SetUp() { _comparerB = Substitute.For>(); } [Test] public void GetObjectsComparerGeneric() { var settings = new ComparisonSettings(); var factory = new ComparersFactory(); var comparer = factory.GetObjectsComparer(settings); Assert.AreEqual(settings, comparer.Settings); } [Test] public void GetObjectsComparer() { var settings = new ComparisonSettings(); var factory = new ComparersFactory(); var comparer = factory.GetObjectsComparer(typeof(string), settings); Assert.AreEqual(settings, comparer.Settings); } [Test] public void CustomFactoryGenericMethod() { var factory = new CustomFactory(_comparerB); var comparer = factory.GetObjectsComparer(); Assert.AreEqual(_comparerB, comparer); } [Test] public void CustomFactoryNongenericMethod() { var factory = new CustomFactory(_comparerB); var comparer = factory.GetObjectsComparer(typeof(B)); var b1 = new B(); var b2 = new B(); _comparerB.CalculateDifferences(b1, b2).Returns(new List()); var isEqual = comparer.Compare(typeof(B), b1, b2); Assert.IsTrue(isEqual); _comparerB.Received().CalculateDifferences(b1, b2); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ComparisonSettingsTests.cs ================================================ using System.Collections.Generic; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class ComparisonSettingsTests { [Test] public void SetgetCustomSettingWithoutKey() { var settings = new ComparisonSettings(); settings.SetCustomSetting("test string"); var settingValue = settings.GetCustomSetting(); Assert.AreEqual("test string", settingValue); } [Test] public void SetgetCustomSettingWithKey() { var settings = new ComparisonSettings(); settings.SetCustomSetting(123, "setting1"); settings.SetCustomSetting(234, "setting2"); var setting1Value = settings.GetCustomSetting("setting1"); var setting2Value = settings.GetCustomSetting("setting2"); Assert.AreEqual(123, setting1Value); Assert.AreEqual(234, setting2Value); } [Test] public void WronkKey() { var settings = new ComparisonSettings(); settings.SetCustomSetting(123, "setting1"); Assert.Throws(() => settings.GetCustomSetting("wrongSettingKey")); } [Test] public void WronkType() { var settings = new ComparisonSettings(); settings.SetCustomSetting(123, "setting1"); Assert.Throws(() => settings.GetCustomSetting("setting1")); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/CustomComparers/AbstractValueComparerTests.cs ================================================ using NSubstitute; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class AbstractValueComparerTests { [Test] public void DefaultToString() { var valueComparer = Substitute.ForPartsOf>(); var result = valueComparer.ToString("str1"); Assert.AreEqual("str1", result); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/CustomComparers/DynamicValueComparerTests.cs ================================================ using System; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class DynamicValueComparerTests { [Test] public void ConstructorNullCompareFunc() { // ReSharper disable once ObjectCreationAsStatement Assert.Throws(() => new DynamicValueComparer(null, s => s)); } [Test] public void ConstructorNullToStringFunc() { // ReSharper disable once ObjectCreationAsStatement Assert.Throws(() => new DynamicValueComparer((s1, s2, settings) => true, null)); } [Test] public void CompareWrongFirstArgument() { var comparer = new DynamicValueComparer((s1, s2, settings) => true, s => s); Assert.Throws(() => comparer.Compare(25, "25", new ComparisonSettings())); } [Test] public void CompareWrongSecondArgument() { var comparer = new DynamicValueComparer((s1, s2, settings) => true, s => s); Assert.Throws(() => comparer.Compare("25", 25, new ComparisonSettings())); } [Test] public void CompareFirstArgumentNullNotValueType() { var comparer = new DynamicValueComparer((s1, s2, settings) => s1 == s2, s => s); var result = comparer.Compare(null, "25", new ComparisonSettings()); Assert.IsFalse(result); } [Test] public void CompareFirstArgumentNullValueType() { var comparer = new DynamicValueComparer((i1, i2, settings) => i1 == i2, i => i.ToString()); Assert.Throws(() => comparer.Compare(null, 25, new ComparisonSettings())); } [Test] public void CompareSecondArgumentNullNotValueType() { var comparer = new DynamicValueComparer((s1, s2, settings) => s1 == s2, s => s); var result = comparer.Compare("23", null, new ComparisonSettings()); Assert.IsFalse(result); } [Test] public void CompareSecondArgumentNullValueType() { var comparer = new DynamicValueComparer((i1, i2, settings) => i1 == i2, i => i.ToString()); Assert.Throws(() => comparer.Compare(23, null, new ComparisonSettings())); } [TestCase("Str1", "Str2", true)] [TestCase("Str1", "Str1", true)] [TestCase("Str1", "Str", false)] public void Compare(string str1, string str2, bool expectedResult) { var comparer = new DynamicValueComparer((s1, s2, settings) => s1.Length == s2.Length, s => s); var result = comparer.Compare(str1, str2, new ComparisonSettings()); var toString = comparer.ToString(str1); Assert.AreEqual(expectedResult, result); Assert.AreEqual(str1, toString); } [TestCase("Str1", "Str2", true)] [TestCase("Str1", "Str1", true)] [TestCase("Str1", "Str", false)] public void CompareWithDefaultToString(string str1, string str2, bool expectedResult) { var comparer = new DynamicValueComparer((s1, s2, settings) => s1.Length == s2.Length); var result = comparer.Compare(str1, str2, new ComparisonSettings()); var toString = comparer.ToString(str1); Assert.AreEqual(expectedResult, result); Assert.AreEqual(str1, toString); } [Test] public void NulableType() { DateTime? dt1 = null; DateTime? dt2 = null; var dateComparer = new DynamicValueComparer ((date1, date2, settings) => date1 == date2 || (date1 != null && date2 != null && date1.Value.Date == date2.Value.Date)); var comparer = new Comparer(); comparer.AddComparerOverride(dateComparer); var result = comparer.Compare(dt1, dt2); Assert.IsTrue(result); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/CustomComparers/EnumerablesComparerGenericTests.cs ================================================ using NUnit.Framework; using System; using System.Collections.Generic; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class EnumerablesComparerGenericTests { [Test] public void FirstParameterNotEnumerable() { var comparer = new EnumerablesComparer(new ComparisonSettings(), null, null); var obj1 = new List(); var obj2 = new List(); Assert.Throws(() => comparer.Compare(typeof(List), obj1, obj2)); } [Test] public void SecondParameterNotEnumerable() { var comparer = new EnumerablesComparer(new ComparisonSettings(), null, null); var obj1 = new List(); var obj2 = new A(); Assert.Throws(() => comparer.Compare(typeof(List), obj1, obj2)); } [Test] public void TypeNotIEnumerable() { var comparer = new EnumerablesComparer(new ComparisonSettings(), null, null); var obj1 = new List(); var obj2 = new List(); Assert.Throws(() => comparer.Compare(typeof(int), obj1, obj2)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/CustomComparers/EnumerablesComparerTests.cs ================================================ using NUnit.Framework; using System; using System.Collections.Generic; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class EnumerablesComparerTests { [Test] public void FirstParameterNotEnumerable() { var comparer = new EnumerablesComparer(new ComparisonSettings(), null, null); var obj1 = 25; var obj2 = new List(); Assert.Throws(() => comparer.Compare(typeof(List), obj1, obj2)); } [Test] public void SecondParameterNotEnumerable() { var comparer = new EnumerablesComparer(new ComparisonSettings(), null, null); var obj1 = new List(); var obj2 = new A(); Assert.Throws(() => comparer.Compare(typeof(List), obj1, obj2)); } [Test] public void TypeNotIEnumerable() { var comparer = new EnumerablesComparer(new ComparisonSettings(), null, null); var obj1 = new List(); var obj2 = new List(); Assert.Throws(() => comparer.Compare(typeof(int), obj1, obj2)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/CustomComparers/HashSetsComparerTests.cs ================================================ using NUnit.Framework; using System; using System.Collections.Generic; using ObjectsComparer.Tests.TestClasses; namespace ObjectsComparer.Tests { [TestFixture] public class HashSetsComparerTests { [Test] public void FirstParameterNotEnumerable() { var comparer = new HashSetsComparer(new ComparisonSettings(), null, null); var obj1 = 25; var obj2 = new HashSet(); Assert.Throws(() => comparer.Compare(typeof(HashSet), obj1, obj2)); } [Test] public void SecondParameterNotEnumerable() { var comparer = new HashSetsComparer(new ComparisonSettings(), null, null); var obj1 = new HashSet(); var obj2 = new A(); Assert.Throws(() => comparer.Compare(typeof(HashSet), obj1, obj2)); } [Test] public void TypeNotHashSet() { var comparer = new HashSetsComparer(new ComparisonSettings(), null, null); var obj1 = new HashSet(); var obj2 = new HashSet(); Assert.Throws(() => comparer.Compare(typeof(int), obj1, obj2)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/CustomComparers/TypesComparerTests.cs ================================================ using NUnit.Framework; using System; namespace ObjectsComparer.Tests { [TestFixture] public class TypesComparerTests { [Test] public void FirstParameterNotType() { var comparer = new TypesComparer(new ComparisonSettings(), null, null); var obj1 = 25; var obj2 = typeof(string); Assert.Throws(() => comparer.Compare(typeof(Type), obj1, obj2)); } [Test] public void SecondParameterNotEnumerable() { var comparer = new TypesComparer(new ComparisonSettings(), null, null); var obj1 = typeof(string); var obj2 = 25; Assert.Throws(() => comparer.Compare(typeof(Type), obj1, obj2)); } [Test] public void NullsAreEqual() { var comparer = new TypesComparer(new ComparisonSettings(), null, null); Assert.IsTrue(comparer.Compare(typeof(Type), null, null)); } [Test] public void SameTypesAreEqual() { var comparer = new TypesComparer(new ComparisonSettings(), null, null); var obj1 = typeof(string); var obj2 = typeof(string); Assert.IsTrue(comparer.Compare(typeof(Type), obj1, obj2)); } [Test] public void DifferentTypesAreNotEqual() { var comparer = new TypesComparer(new ComparisonSettings(), null, null); var obj1 = typeof(string); var obj2 = typeof(bool); Assert.IsFalse(comparer.Compare(typeof(Type), obj1, obj2)); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/DifferenceTests.cs ================================================ using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class DifferenceTests { [Test] public void DifferenceToString() { var difference = new Difference("Property1", "12345", "12346"); var toString = difference.ToString(); Assert.IsTrue(toString.Contains("Property1")); Assert.IsTrue(toString.Contains("12345")); Assert.IsTrue(toString.Contains("12346")); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ObjectsComparer.Tests.csproj ================================================  netcoreapp3.0;netcoreapp2.0;net45 ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ObjectsComparer.Tests.csproj.DotSettings ================================================  True True ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ParentInterfacePropertiesTests.cs ================================================ using System.Collections.Generic; using System.Linq; using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class ParentInterfacePropertiesTests { interface IParent { string Property1 { get; set; } } interface IChild : IParent { string Property2 { get; set; } } class Child : IChild { public string Property1 { get; set; } public string Property2 { get; set; } } [Test] public void ComparePropertyOfParentInterface() { var a1 = new Child {Property1 = "str11", Property2 = "str12"}; var a2 = new Child {Property1 = "str21", Property2 = "str22"}; var comparer = new Comparer(); var differences = comparer.CalculateDifferences(a1, a2).ToList(); Assert.AreEqual(2, differences.Count); Assert.AreEqual("Property1", differences[1].MemberPath); Assert.AreEqual("str11", differences[1].Value1); Assert.AreEqual("str21", differences[1].Value2); Assert.AreEqual("Property2", differences[0].MemberPath); Assert.AreEqual("str12", differences[0].Value1); Assert.AreEqual("str22", differences[0].Value2); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/A.cs ================================================ using System; using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics; namespace ObjectsComparer.Tests.TestClasses { internal class A { public int Field; protected int ProtectedField; public readonly string ReadOnlyField; public int IntProperty { get; set; } public string TestProperty1 { get; set; } public string TestProperty2 { get; set; } public DateTime DateTimeProperty { get; set; } public double ReadOnlyProperty { get; } protected bool ProtectedProperty { get; } public B ClassB { get; set; } public int[] IntArray { get; set; } public B[] ArrayOfB { get; set; } public Collection CollectionOfB { get; set; } public IEnumerable EnumerableOfB { get; set; } public List ListOfB { get; set; } public Dictionary DictionaryOfB { get; set; } public CollectionOfB ClassImplementsCollectionOfB { get; set; } public ITestInterface IntefaceProperty { get; set; } public TestStruct StructProperty { get; set; } public TestEnum EnumProperty { get; set; } public IEnumerable NonGenericEnumerable { get; set; } public EnumerableImplementation NonGenericEnumerableImplementation { get; set; } public FlagsEnum Flags { get; set; } public Type TypeProperty { get; set; } public int Property3 { set { if (value > 3) { Debug.WriteLine("value > 3"); } } } public A() { ReadOnlyProperty = 3.14; } public A(double readOnlyProperty) { ReadOnlyProperty = readOnlyProperty; } public A(int protectedField) { ProtectedField = protectedField; } public A(string readOnlyField) { ReadOnlyField = readOnlyField; } public A(bool protectedProperty) { ProtectedProperty = protectedProperty; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/B.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { public class B { public string Property1 { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/Child.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { using ObjectsComparer.Attributes; public class Child { #region Constructors public Child(string property1, string property2) { this.Property1 = property1; this.Property2 = property2; } #endregion #region Properties public string Property1 { get; set; } [IgnoreInComparison] public string Property2 { get; set; } #endregion } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/CollectionOfB.cs ================================================ using System; using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics; namespace ObjectsComparer.Tests.TestClasses { internal class CollectionOfB: IProgress, ICollection { public string Property1 { get; set; } public int Count => _collection.Count; public bool IsReadOnly => false; private readonly Collection _collection; public CollectionOfB() { _collection = new Collection(); } public void Report(string value) => Debug.WriteLine(value); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); public IEnumerator GetEnumerator() => _collection.GetEnumerator(); public void Add(B item) => _collection.Add(item); public void Clear() => _collection.Clear(); public bool Contains(B item) => _collection.Contains(item); public void CopyTo(B[] array, int arrayIndex) => _collection.CopyTo(array, arrayIndex); public bool Remove(B item) => _collection.Remove(item); } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/EnumerableImplementation.cs ================================================ using System.Collections; namespace ObjectsComparer.Tests.TestClasses { internal class EnumerableImplementation: IEnumerable { public string Property1 { get; set; } private readonly IEnumerable _enumerable; public EnumerableImplementation(IEnumerable enumerable) { _enumerable = enumerable; } public IEnumerator GetEnumerator() { return _enumerable.GetEnumerator(); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/FlagsEnum.cs ================================================ using System; namespace ObjectsComparer.Tests.TestClasses { [Flags] public enum FlagsEnum { Flag1 = 1, Flag2 = 2, Flag3 = 4, Flag4 = 8 } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/ITestInterface.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { internal interface ITestInterface { string Property { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/InheritedFromB.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { internal class InheritedFromB: B { public string NewProperty { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/MultidimensionalArrays.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { public class MultidimensionalArrays { public int[,] IntInt { get; set; } public int[][] IntOfInt { get; set; } public int[][,] IntOfIntInt { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/Parent.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { using System.Collections.ObjectModel; public class Parent { public string Property1 { get; set; } public ObservableCollection Child1 { get; set; } = new ObservableCollection (); } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/ParentChild.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { using System.Collections.ObjectModel; using NUnit.Framework; using ObjectsComparer.Attributes; public class ParentChild { #region Constructors public ParentChild(Parent myParent, string property1) { this.MyParent = myParent; this.Property1 = property1; } public ParentChild(Parent myParent, string property1, ObservableCollection children) { this.MyParent = myParent; this.Property1 = property1; this.Children = children; } #endregion #region Properties public string Property1 { get; set; } [IgnoreInComparison] public Parent MyParent { get; set; } public ObservableCollection Children { get; set; } = new ObservableCollection (); #endregion } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/TestEnum.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { internal enum TestEnum { Value1, Value2 } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/TestInterfaceImplementation1.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { internal class TestInterfaceImplementation1: ITestInterface { public string Property { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/TestInterfaceImplementation2.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { internal class TestInterfaceImplementation2: ITestInterface { public string Property { get; set; } public int AnotherProperty { get; set; } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/TestClasses/TestStruct.cs ================================================ namespace ObjectsComparer.Tests.TestClasses { internal struct TestStruct { public string FieldA; public string FieldB; } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/Utils/TypeExtensionsTests.cs ================================================ using System; using System.Collections.Generic; using NUnit.Framework; using ObjectsComparer.Utils; namespace ObjectsComparer.Tests.Utils { [TestFixture] public class TypeExtensionsTests { [Test] public void InheritsFromFirstTypeNull() { var result = ((Type) null).InheritsFrom(typeof(string)); Assert.IsFalse(result); } [Test] public void InheritsFromSecondTypeNull() { var result = typeof(string).InheritsFrom(null); Assert.IsFalse(result); } [Test] public void InheritsFromEqualTypes() { var result = typeof(string).InheritsFrom(typeof(string)); Assert.IsTrue(result); } [Test] public void InheritsFromEqualGenericTypes() { var result = typeof(List).InheritsFrom(typeof(List)); Assert.IsTrue(result); } [Test] public void InheritsFromEqualGenericTypeAndGenericDefinition() { var result = typeof(List).InheritsFrom(typeof(List<>)); Assert.IsTrue(result); } [Test] public void InheritsFromEqualGenericTypeAndGenericInterface() { var result = typeof(List).InheritsFrom(typeof(IList<>)); Assert.IsTrue(result); } [Test] public void InheritsFromEqualTypeAndBaseType() { var result = typeof(string).InheritsFrom(typeof(object)); Assert.IsTrue(result); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ValueComparers/DefaultValueComparerTests.cs ================================================ using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class DefaultValueComparerTests { [TestCase(null, null, true)] [TestCase(5, null, false)] [TestCase(null, "string", false)] [TestCase(5, "string", false)] [TestCase(5, 5, true)] [TestCase(5, 7, false)] [TestCase("string1", "string1", true)] [TestCase("string1", "string2", false)] public void Compare(object obj1, object obj2, bool expectedResult) { var comparer = new DefaultValueComparer(); var actualResult = comparer.Compare(obj1, obj2, new ComparisonSettings()); Assert.AreEqual(expectedResult, actualResult); } [TestCase(null, "")] [TestCase(5, "5")] [TestCase("str1", "str1")] [TestCase(true, "True")] public void Compare(object value, string expectedResult) { var comparer = new DefaultValueComparer(); var actualResult = comparer.ToString(value); Assert.AreEqual(expectedResult, actualResult); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ValueComparers/DefaultValueValueComparerTests.cs ================================================ using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class DefaultValueValueComparerTests { [TestCase(0, 5, true)] [TestCase(null, 5, true)] [TestCase(5, 0, true)] [TestCase(5, null, true)] [TestCase(5, 0, true)] [TestCase(0, 5, true)] [TestCase(0, 0, true)] [TestCase(5, 5, true)] [TestCase(null, 7, false)] [TestCase(0, 7, false)] [TestCase(5, 7, false)] [TestCase(7, null, false)] [TestCase(7, 0, false)] [TestCase(7, 5, false)] [TestCase(7, 8, false)] public void ValueType(object obj1, object obj2, bool expectedResult) { var comparer = new DefaultValueValueComparer(5, new DefaultValueComparer()); var actualResult = comparer.Compare(obj1, obj2, new ComparisonSettings()); Assert.AreEqual(expectedResult, actualResult); } [TestCase(null, "none", true)] [TestCase("none", null, true)] [TestCase(null, null, true)] [TestCase("none", "none", true)] [TestCase(null, "string", false)] [TestCase("string", null, false)] [TestCase("none", "string", false)] [TestCase("string", "none", false)] [TestCase("string1", "string2", false)] public void ReferenceType(object obj1, object obj2, bool expectedResult) { var comparer = new DefaultValueValueComparer("none", new DefaultValueComparer()); var actualResult = comparer.Compare(obj1, obj2, new ComparisonSettings()); Assert.AreEqual(expectedResult, actualResult); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ValueComparers/DoNotCompareValueComparerTests.cs ================================================ using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class DoNotCompareValueComparerTests { [Test] public void Instance() { Assert.IsNotNull(DoNotCompareValueComparer.Instance); } [Test] public void Compare() { var result = DoNotCompareValueComparer.Instance.Compare(25, "String", new ComparisonSettings()); Assert.IsTrue(result); } [TestCase(25)] [TestCase("String")] [TestCase(12.5)] [TestCase(null)] public void ToString(object value) { var result = DoNotCompareValueComparer.Instance.ToString(value); Assert.AreEqual(string.Empty, result); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ValueComparers/IgnoreCaseStringsValueComparerTests.cs ================================================ using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class IgnoreCaseStringsValueComparerTests { [TestCase(null, null, true)] [TestCase("", "", true)] [TestCase("str", "str", true)] [TestCase(null, "s", false)] [TestCase("hhh", null, false)] [TestCase("hhh", "s", false)] [TestCase("hhh", "HHH", true)] [TestCase("hhh", "HHH", true)] [TestCase("Go", "go", true)] public void Compare(string s1, string s2, bool expectedResult) { var comparer = new IgnoreCaseStringsValueComparer(); var result = comparer.Compare(s1, s2, new ComparisonSettings()); Assert.AreEqual(expectedResult, result); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.Tests/ValueComparers/NulableStringsValueComparerTests.cs ================================================ using NUnit.Framework; namespace ObjectsComparer.Tests { [TestFixture] public class NulableStringsValueComparerTests { [TestCase(null, null, true)] [TestCase(null, "", true)] [TestCase("", null, true)] [TestCase("", "", true)] [TestCase("str", "str", true)] [TestCase(null, "s", false)] [TestCase("hhh", null, false)] [TestCase("hhh", "s", false)] public void Compare(string s1, string s2, bool expectedResult) { var comparer = new NulableStringsValueComparer(); var result = comparer.Compare(s1, s2, new ComparisonSettings()); Assert.AreEqual(expectedResult, result); } [TestCase(null, "")] [TestCase("", "")] [TestCase("ss", "ss")] public void ToString(string s, string expectedToString) { var comparer = new NulableStringsValueComparer(); var result = comparer.ToString(s); Assert.AreEqual(expectedToString, result); } } } ================================================ FILE: ObjectsComparer/ObjectsComparer.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 15 VisualStudioVersion = 15.0.27428.2011 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ObjectsComparer", "ObjectsComparer\ObjectsComparer.csproj", "{1EE94257-5FF4-4453-BF88-BCA30AFCA126}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ObjectsComparer.Tests", "ObjectsComparer.Tests\ObjectsComparer.Tests.csproj", "{73D87409-FEBB-4CFF-90EE-B1F0F8BAFDF7}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ObjectsComparer.Examples", "ObjectsComparer.Examples\ObjectsComparer.Examples.csproj", "{EC727489-24B0-4654-B454-E58698DF384A}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {1EE94257-5FF4-4453-BF88-BCA30AFCA126}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1EE94257-5FF4-4453-BF88-BCA30AFCA126}.Debug|Any CPU.Build.0 = Debug|Any CPU {1EE94257-5FF4-4453-BF88-BCA30AFCA126}.Release|Any CPU.ActiveCfg = Release|Any CPU {1EE94257-5FF4-4453-BF88-BCA30AFCA126}.Release|Any CPU.Build.0 = Release|Any CPU {73D87409-FEBB-4CFF-90EE-B1F0F8BAFDF7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {73D87409-FEBB-4CFF-90EE-B1F0F8BAFDF7}.Debug|Any CPU.Build.0 = Debug|Any CPU {73D87409-FEBB-4CFF-90EE-B1F0F8BAFDF7}.Release|Any CPU.ActiveCfg = Release|Any CPU {73D87409-FEBB-4CFF-90EE-B1F0F8BAFDF7}.Release|Any CPU.Build.0 = Release|Any CPU {EC727489-24B0-4654-B454-E58698DF384A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {EC727489-24B0-4654-B454-E58698DF384A}.Debug|Any CPU.Build.0 = Debug|Any CPU {EC727489-24B0-4654-B454-E58698DF384A}.Release|Any CPU.ActiveCfg = Release|Any CPU {EC727489-24B0-4654-B454-E58698DF384A}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {3DFB6A53-C530-438E-BB1A-A29CE93CC23F} EndGlobalSection EndGlobal ================================================ FILE: README.md ================================================ ![Logo](https://github.com/ValeraT1982/ObjectsComparer/blob/master/ObjectsDataComparer.png) # Objects Comparer ## Introduction It is quite common situation when complex objects should be compared. Sometimes objects can contain nested elements, or some members should be excluded from comparison (auto generated identifiers, create/update date etc.), or some members can have custom comparison rules (same data in different formats, like phone numbers). This small framework was developed to solve such kind of problems. Briefly, Objects Comparer is an object-to-object comparer, which allows to compare objects recursively member by member and define custom comparison rules for certain properties, fields or types. Objects comparer can be considered as ready to use framework or as a starting point for similar solutions. ## Installation >Install-Package ObjectsComparer ## Basic Examples Let's suppose that we have 2 classes ```csharp public class ClassA { public string StringProperty { get; set; } public int IntProperty { get; set; } public SubClassA SubClass { get; set; } } public class SubClassA { public bool BoolProperty { get; set; } } ``` There are some examples below how Objects Comparer can be used to compare instances of these classes. ```csharp //Initialize objects and comparer var a1 = new ClassA { StringProperty = "String", IntProperty = 1 }; var a2 = new ClassA { StringProperty = "String", IntProperty = 1 }; var comparer = new Comparer(); //Compare objects IEnumerable differences; var isEqual = comparer.Compare(a1, a2, out differences); //Print results Debug.WriteLine(isEqual ? "Objects are equal" : string.Join(Environment.NewLine, differenses)); ``` >Objects are equal In examples below **Compare objects** and **Print results** blocks will be skipped for brevity except some cases. ```csharp var a1 = new ClassA { StringProperty = "String", IntProperty = 1 }; var a2 = new ClassA { StringProperty = "String", IntProperty = 2 }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='IntProperty', Value1='1', Value2='2'. ```csharp var a1 = new ClassA { SubClass = new SubClassA { BoolProperty = true } }; var a2 = new ClassA { SubClass = new SubClassA { BoolProperty = false } }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='SubClass.BoolProperty', Value1='True', Value2='False'. ```csharp var a1 = new StringBuilder("abc"); var a2 = new StringBuilder("abd"); var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='', Value1='abc', Value2='abd'. ## Enumerables (arrays) ```csharp var a1 = new[] { 1, 2, 3 }; var a2 = new[] { 1, 2, 3 }; var comparer = new Comparer(); ``` >Objects are equal ```csharp var a1 = new[] { 1, 2 }; var a2 = new[] { 1, 2, 3 }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Length', Value1='2', Value2='3'. ```csharp var a1 = new[] { 1, 2, 3 }; var a2 = new[] { 1, 4, 3 }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='[1]', Value1='2', Value2='4'. ```csharp var a1 = new ArrayList { "Str1", "Str2" }; var a2 = new ArrayList { "Str1", 5 }; var comparer = new Comparer(); ``` >Difference: DifferenceType=TypeMismatch, MemberPath='[1]', Value1='Str2', Value2='5'. ## Sets ```csharp var a1 = new[] { 1, 2, 3 }; var a2 = new[] { 1, 2, 3 }; var comparer = new Comparer(); ``` >Objects are equal ```csharp var a1 = new HashSet { 1, 2, 3 }; var a2 = new HashSet { 2, 1, 4 }; var comparer = new Comparer>(); ``` >Difference: DifferenceType=MissedElementInSecondObject, MemberPath='', Value1='3', Value2=''. >Difference: DifferenceType=MissedElementInFirstObject, MemberPath='', Value1='', Value2='4'. ## Multidimensional arrays ```csharp var a1 = new[] { new[] { 1, 2 } }; var a2 = new[] { new[] { 1, 3 } }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='[0][1]', Value1='2', Value2='3'. ```csharp var a1 = new[] { new[] { 1, 2 } }; var a2 = new[] { new[] { 2, 2 }, new[] { 3, 5 } }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Length', Value1='1', Value2='2'. ```csharp var a1 = new[] { new[] { 1, 2 }, new[] { 3, 5 } }; var a2 = new[] { new[] { 1, 2 }, new[] { 3, 5, 6 } }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='[1].Length', Value1='2', Value2='3'. ```csharp var a1 = new[,] { { 1, 2 }, { 1, 3 } }; var a2 = new[,] { { 1, 3, 4 }, { 1, 3, 8 } }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Dimension1', Value1='2', Value2='3'. ```csharp var a1 = new[,] { { 1, 2 } }; var a2 = new[,] { { 1, 3 } }; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='[0,1]', Value1='2', Value2='3'. ## Dynamic objects C# supports several types of dynamic objects. ### ExpandoObject ```csharp dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 5; a1.Field4 = 4; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field3 = false; a2.Field4 = "C"; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Field1', Value1='A', Value2='B'. >Difference: DifferenceType=MissedMemberInSecondObject, MemberPath='Field2', Value1='5', Value2=''. >Difference: DifferenceType=TypeMismatch, MemberPath='Field4', Value1='4', Value2='C'. >Difference: DifferenceType=MissedMemberInFirstObject, MemberPath='Field3', Value1='', Value2='False'. ```csharp dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 5; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field3 = false; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Field1', Value1='A', Value2='B'. >Difference: DifferenceType=MissedMemberInSecondObject, MemberPath='Field2', Value1='5', Value2=''. >Difference: DifferenceType=MissedMemberInFirstObject, MemberPath='Field3', Value1='', Value2='False'. Behavior if member not exists could be changed by providing custom ComparisonSettings (see Comparison Settings below). ```csharp dynamic a1 = new ExpandoObject(); a1.Field1 = "A"; a1.Field2 = 0; dynamic a2 = new ExpandoObject(); a2.Field1 = "B"; a2.Field3 = false; a2.Field4 = "S"; var comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Field1', Value1='A', Value2='B'. >Difference: DifferenceType=ValueMismatch, MemberPath='Field4', Value1='', Value2='S'. ### DynamicObject Let’s assume that we have such implementation of the **DynamicObject** class. It is necessary to have a correct implementation of the method **GetDynamicMemberNames**, otherwise Objects Comparer wouldn't work in a right way. ```csharp private class DynamicDictionary : DynamicObject { public int IntProperty { get; set; } private readonly Dictionary _dictionary = new Dictionary(); public override bool TryGetMember(GetMemberBinder binder, out object result) { var name = binder.Name; return _dictionary.TryGetValue(name, out result); } public override bool TrySetMember(SetMemberBinder binder, object value) { _dictionary[binder.Name] = value; return true; } public override IEnumerable GetDynamicMemberNames() { return _dictionary.Keys; } } ``` ```csharp dynamic a1 = new DynamicDictionary(); a1.Field1 = "A"; a1.Field3 = true; dynamic a2 = new DynamicDictionary(); a2.Field1 = "B"; a2.Field2 = 8; a2.Field3 = 1; var comparer = new Comparer(); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Field1', Value1='A', Value2='B'. >Difference: DifferenceType=TypeMismatch, MemberPath='Field3', Value1='True', Value2='1'. >Difference: DifferenceType=MissedMemberInFirstObject, MemberPath='Field2', Value1='', Value2='8'. ### Compiler generated objects ```csharp dynamic a1 = new { Field1 = "A", Field2 = 5, Field3 = true }; dynamic a2 = new { Field1 = "B", Field2 = 8 }; var comparer = new Comparer(); IEnumerable differences; var isEqual = comparer.Compare((object)a1, (object)a2, out differences); ``` >Difference: DifferenceType=ValueMismatch, MemberPath='Field1', Value1='A', Value2='B'. >Difference: DifferenceType=TypeMismatch, MemberPath='Field2', Value1='5', Value2='8'. >Difference: DifferenceType=MissedMemberInSecondObject, MemberPath='Field3', Value1='True', Value2=''. This example requires some additional explanations. Types of the objects a1 and a2 were generated by compiler and are considered as the same type if and only if objects a1 and a2 have same set of members (same name and same type). If casting to **(object)** is skipped in case of different set of members **RuntimeBinderException** will be thrown. ## Overriding Comparison Rules To override comparison rule we need to create custom value comparer or provide function how to compare objects and how to convert these objects to string(optional) and filter function(optional). Value Comparer should be inherited from **AbstractValueComparer** or should implement **IValueComparer**. ```csharp public class MyValueComparer: AbstractValueComparer { public override bool Compare(string obj1, string obj2, ComparisonSettings settings) { return obj1 == obj2; //Implement comparison logic here } } ``` Override comparison rule for objects of particular type. ```csharp //Use MyComparer to compare all members of type string comparer.AddComparerOverride(new MyValueComparer()); comparer.AddComparerOverride(typeof(string), new MyValueComparer()); //Use MyComparer to compare all members of type string except members which name starts with "Xyz" comparer.AddComparerOverride(typeof(string), new MyValueComparer(), member => !member.Name.StartsWith("Xyz")); comparer.AddComparerOverride(new MyValueComparer(), member => !member.Name.StartsWith("Xyz")); ``` Override comparison rule for particular member (Field or Property). ```csharp //Use MyValueComparer to compare StringProperty of ClassA comparer.AddComparerOverride(() => new ClassA().StringProperty, new MyValueComparer()); comparer.AddComparerOverride( typeof(ClassA).GetTypeInfo().GetMember("StringProperty").First(), new MyValueComparer()); //Compare StringProperty of ClassA by length. If length equal consider that values are equal comparer.AddComparerOverride( () => new ClassA().StringProperty, (s1, s2, parentSettings) => s1?.Length == s2?.Length, s => s.ToString()); comparer.AddComparerOverride( () => new ClassA().StringProperty, (s1, s2, parentSettings) => s1?.Length == s2?.Length); ``` Override comparison rule for particular member(s) (Field or Property) by name. ```csharp //Use MyValueComparer to compare all members with name equal to "StringProperty" comparer.AddComparerOverride("StringProperty", new MyValueComparer()); ``` Override comparison rule by member filter. ```csharp comparer.AddComparerOverride(new MyValueComparer(), m => m.Name == "StringProperty"); ``` Overrides by type have highest priority, then overrides by member/member filter and overrides by member name have lowest priority. If more than one value comparers of the same type (by type/by name/by member name) could be applied to the same member, exception **AmbiguousComparerOverrideResolutionException** will be thrown during comparison. Example: ```csharp var a1 = new ClassA(); var a2 = new ClassA(); comparer.AddComparerOverride(valueComparer1, member => member.Name.StartsWith("String")); comparer.AddComparerOverride(valueComparer2, member => member.Name.EndsWith("Property")); var result = comparer.Compare(a1, a2);//Exception here ``` ## Ignoring members Ignores members of particular type. ```csharp comparer.IgnoreMember(); ``` Ignores particular member. ```csharp comparer.IgnoreMember(() => new A().TestProperty1); ``` Ignores by member filter. ```csharp comparer.IgnoreMember(member => member.Name == "TestProperty1"); ``` Ignores particular member by name. ```csharp comparer.IgnoreMember("TestProperty1"); ``` ## Comparison Settings Comparer constructor has an optional **settings** parameter to configure some aspects of comparison. **RecursiveComparison** True by default. If true, all members which are not primitive types, do not have custom comparison rule and do not implement **ICompareble** will be compared using the same rules as root objects. **EmptyAndNullEnumerablesEqual** False by default. If true, empty enumerables (arrays, collections, lists etc.) and null values will be considered as equal values. **UseDefaultIfMemberNotExist** If true and member does not exist, objects comparer will consider that this member is equal to default value of opposite member type. Applicable for dynamic types comparison only. False by default. Comparison Settings class allows to store custom values that can be used in custom comparers. ```csharp SetCustomSetting(T value, string key = null) GetCustomSetting(string key = null) ``` ## Factory Factory provides a way to encapsulate comparers creation and configuration. Factory should implement **IComparersFactory** or should be inherited from **ComparersFactory**. ```csharp public class MyComparersFactory: ComparersFactory { public override IComparer GetObjectsComparer(ComparisonSettings settings = null, IBaseComparer parentComparer = null) { if (typeof(T) == typeof(ClassA)) { var comparer = new Comparer(settings, parentComparer, this); comparer.AddComparerOverride(new MyCustomGuidComparer()); return (IComparer)comparer; } return base.GetObjectsComparer(settings, parentComparer); } } ``` ## Non-generic comparer ```csharp var comparer = new Comparer(); var isEqual = comparer.Compare(a1, a2); ``` This comparer creates generic implementation of comparer for each comparison. ## Useful Value Comparers Framework contains several custom comparers that can be useful in many cases. **DoNotCompareValueComparer** Allows to skip some fields/types. Has singleton implementation (**DoNotCompareValueComparer.Instance**). P.S. **IgnoreMember** methods is more convenient way to skip fields/types. This comparer is needed if override require custom filter and for backward compatibility. **DynamicValueComparer** Receives comparison rule as a function. **NulableStringsValueComparer** Null and empty strings are considered as equal values. Has singleton implementation (**NulableStringsValueComparer.Instance**). **DefaultValueValueComparer** Allows to consider provided value and default value of specified type as equal values (see Example 3 below). **IgnoreCaseStringsValueComparer** Allows to compare string ignoring case. Has singleton implementation (**IgnoreCaseStringsValueComparer.Instance**). **UriComparer** Allows to compare Uri objects. ## Examples There are some more complex examples how Objects Comparer can be used. ### Example 1: Expected Message #### Challenge Check if received message equal to the expected message. #### Problems * **DateCreated**, **DateSent** and **DateReceived** properties need to be skipped * Auto generated **Id** property need to be skipped * **Message** property of **Error** class need to be skipped #### Solution ```csharp public class Error { public int Id { get; set; } public string Messgae { get; set; } } ``` ```csharp public class Message { public string Id { get; set; } public DateTime DateCreated { get; set; } public DateTime DateSent { get; set; } public DateTime DateReceived { get; set; } public int MessageType { get; set; } public int Status { get; set; } public List Errors { get; set; } public override string ToString() { return $"Id:{Id}, Date:{DateCreated}, Type:{MessageType}, Status:{Status}"; } } ``` Configuring comparer. ```csharp _comparer = new Comparer( new ComparisonSettings { //Null and empty error lists are equal EmptyAndNullEnumerablesEqual = true }); //Do not compare DateCreated _comparer.AddComparerOverride(DoNotCompareValueComparer.Instance); //Do not compare Id _comparer.AddComparerOverride(() => new Message().Id, DoNotCompareValueComparer.Instance); //Do not compare Message Text _comparer.AddComparerOverride(() => new Error().Messgae, DoNotCompareValueComparer.Instance); ``` ```csharp var expectedMessage = new Message { MessageType = 1, Status = 0 }; var actualMessage = new Message { Id = "M12345", DateCreated = DateTime.Now, DateSent = DateTime.Now, DateReceived = DateTime.Now, MessageType = 1, Status = 0 }; IEnumerable differences; var isEqual = _comparer.Compare(expectedMessage, actualMessage, out differences); ``` > Objects are equal ```csharp var expectedMessage = new Message { MessageType = 1, Status = 1, Errors = new List { new Error { Id = 2 }, new Error { Id = 7 } } }; var actualMessage = new Message { Id = "M12345", DateCreated = DateTime.Now, DateSent = DateTime.Now, DateReceived = DateTime.Now, MessageType = 1, Status = 1, Errors = new List { new Error { Id = 2, Messgae = "Some error #2" }, new Error { Id = 7, Messgae = "Some error #7" }, } }; IEnumerable differences; var isEqual = _comparer.Compare(expectedMessage, actualMessage, out differences); ``` > Objects are equal ```csharp var expectedMessage = new Message { MessageType = 1, Status = 1, Errors = new List { new Error { Id = 2, Messgae = "Some error #2" }, new Error { Id = 8, Messgae = "Some error #8" } } }; var actualMessage = new Message { Id = "M12345", DateCreated = DateTime.Now, DateSent = DateTime.Now, DateReceived = DateTime.Now, MessageType = 1, Status = 2, Errors = new List { new Error { Id = 2, Messgae = "Some error #2" }, new Error { Id = 7, Messgae = "Some error #7" } } }; IEnumerable differences; var isEqual = _comparer.Compare(expectedMessage, actualMessage, out differences); ``` > Difference: DifferenceType=ValueMismatch, MemberPath='Status', Value1='1', Value2='2'. > Difference: DifferenceType=ValueMismatch, MemberPath='Errors[1].Id', Value1='8', Value2='7'. ### Example 2: Persons comparison #### Challenge Compare persons from different sources. #### Problems * **PhoneNumber** format can be in different. Example: "111-555-8888" and "(111) 555 8888" * **MiddleName** can exist in one source but does not exist in another source. It makes a sense to compare **MiddleName** only if it has value in both sources. * **PersonId** property need to be skipped #### Solution ```csharp public class Person { public Guid PersonId { get; set; } public string FirstName { get; set; } public string LastName { get; set; } public string MiddleName { get; set; } public string PhoneNumber { get; set; } public override string ToString() { return $"{FirstName} {MiddleName} {LastName} ({PhoneNumber})"; } } ``` Phone number can have different formats. Let’s compare only digits. ```csharp public class PhoneNumberComparer: AbstractValueComparer { public override bool Compare(string obj1, string obj2, ComparisonSettings settings) { return ExtractDigits(obj1) == ExtractDigits(obj2); } private string ExtractDigits(string str) { return string.Join( string.Empty, (str ?? string.Empty) .ToCharArray() .Where(char.IsDigit)); } } ``` Factory allows not to configure comparer every time we need to create it. ```csharp public class MyComparersFactory: ComparersFactory { public override IComparer GetObjectsComparer(ComparisonSettings settings = null, IBaseComparer parentComparer = null) { if (typeof(T) == typeof(Person)) { var comparer = new Comparer(settings, parentComparer, this); //Do not compare PersonId comparer.AddComparerOverride(DoNotCompareValueComparer.Instance); //Sometimes MiddleName can be skipped. Compare only if property has value. comparer.AddComparerOverride( () => new Person().MiddleName, (s1, s2, parentSettings) => string.IsNullOrWhiteSpace(s1) || string.IsNullOrWhiteSpace(s2) || s1 == s2); comparer.AddComparerOverride( () => new Person().PhoneNumber, new PhoneNumberComparer()); return (IComparer)comparer; } return base.GetObjectsComparer(settings, parentComparer); } } ``` Configuring comparer. ```csharp _factory = new MyComparersFactory(); _comparer = _factory.GetObjectsComparer(); ``` ```csharp var person1 = new Person { PersonId = Guid.NewGuid(), FirstName = "John", LastName = "Doe", MiddleName = "F", PhoneNumber = "111-555-8888" }; var person2 = new Person { PersonId = Guid.NewGuid(), FirstName = "John", LastName = "Doe", PhoneNumber = "(111) 555 8888" }; IEnumerable differences; var isEqual = _comparer.Compare(person1, person2, out differences); ``` > Objects are equal ```csharp var person1 = new Person { PersonId = Guid.NewGuid(), FirstName = "Jack", LastName = "Doe", MiddleName = "F", PhoneNumber = "111-555-8888" }; var person2 = new Person { PersonId = Guid.NewGuid(), FirstName = "John", LastName = "Doe", MiddleName = "L", PhoneNumber = "222-555-9999" }; IEnumerable differences; var isEqual = _comparer.Compare(person1, person2, out differences); ``` > Difference: DifferenceType=ValueMismatch, MemberPath='FirstName', Value1='Jack', Value2='John'. > Difference: DifferenceType=ValueMismatch, MemberPath='MiddleName', Value1='F', Value2='L'. > Difference: DifferenceType=ValueMismatch, MemberPath='PhoneNumber', Value1='111-555-8888', Value2='222-555-9999'. ### Example 3: Comparing JSON configuration files #### Challenge There are files with settings with some differences that need to be found. Json.NET is used to deserialize JSON data. #### Problems * URLs can be with or without http prefix. * **DataCompression** is Off by default * **SmartMode1...3** disabled by default  * **ConnectionString**,  **Email** and **Notifications** need to be skipped * If **ProcessTaskTimeout** or **TotalProcessTimeout** settings skipped default values will be used, so if in one file setting does not exists and in another file this setting has default value it is actually the same. #### Files ##### Settings0 ```json { "ConnectionString": "USER ID=superuser;PASSWORD=superpassword;DATA SOURCE=localhost:1111", "Email": { "Port": 25, "Host": "MyHost.com", "EmailAddress": "test@MyHost.com" }, "Settings": { "DataCompression": "On", "DataSourceType": "MultiDataSource", "SomeUrl": "http://MyHost.com/VeryImportantData", "SomeOtherUrl": "http://MyHost.com/NotSoImportantData/", "CacheMode": "Memory", "MaxCacheSize": "1GB", "SuperModes": { "SmartMode1": "Enabled", "SmartMode2": "Disabled", "SmartMode3": "Enabled" } }, "Timeouts": { "TotalProcessTimeout": 500, "ProcessTaskTimeout": 100 }, "BackupSettings": { "BackupIntervalUnit": "Day", "BackupInterval": 100 }, "Notifications": [ { "Phone": "111-222-3333" }, { "Phone": "111-222-4444" }, { "EMail": "support@MyHost.com" } ], "Logging": { "Enabled": true, "Pattern": "Logs\\MyApplication.%data{yyyyMMdd}.log", "MaximumFileSize": "20MB", "Level": "ALL" } } ``` ##### Settings1 ```json { "ConnectionString": "USER ID=admin;PASSWORD=*****;DATA SOURCE=localhost:22222", "Email": { "Port": 25, "Host": "MyHost.com", "EmailAddress": "test@MyHost.com" }, "Settings": { "DataCompression": "On", "DataSourceType": "MultiDataSource", "SomeUrl": "MyHost.com/VeryImportantData", "SomeOtherUrl": "MyHost.com/NotSoImportantData/", "CacheMode": "Memory", "MaxCacheSize": "1GB", "SuperModes": { "SmartMode1": "enabled", "SmartMode3": "enabled" } }, "BackupSettings": { "BackupIntervalUnit": "Day", "BackupInterval": 100 }, "Notifications": [ { "Phone": "111-222-3333" }, { "EMail": "support@MyHost.com" } ], "Logging": { "Enabled": true, "Pattern": "Logs\\MyApplication.%data{yyyyMMdd}.log", "MaximumFileSize": "20MB", "Level": "ALL" } } ``` ##### Settings2 ```json { "ConnectionString": "USER ID=superuser;PASSWORD=superpassword;DATA SOURCE=localhost:1111", "Email": { "Port": 25, "Host": "MyHost.com", "EmailAddress": "test@MyHost.com" }, "Settings": { "DataSourceType": "MultiDataSource", "SomeUrl": "http://MyHost.com/VeryImportantData", "SomeOtherUrl": "http://MyHost.com/NotSoImportantData/", "CacheMode": "Memory", "MaxCacheSize": "1GB", "SuperModes": { "SmartMode3": "Enabled" } }, "Timeouts": { "TotalProcessTimeout": 500, "ProcessTaskTimeout": 200 }, "BackupSettings": { "BackupIntervalUnit": "Week", "BackupInterval": 2 }, "Notifications": [ { "EMail": "support@MyHost.com" } ], "Logging": { "Enabled": false, "Pattern": "Logs\\MyApplication.%data{yyyyMMdd}.log", "MaximumFileSize": "40MB", "Level": "ERROR" } } ``` #### Solution Configuring comparer. ```csharp _comparer = new Comparer(new ComparisonSettings { UseDefaultIfMemberNotExist = true }); //Some fields should be ignored _comparer.AddComparerOverride("ConnectionString", DoNotCompareValueComparer.Instance); _comparer.AddComparerOverride("Email", DoNotCompareValueComparer.Instance); _comparer.AddComparerOverride("Notifications", DoNotCompareValueComparer.Instance); //Smart Modes are disabled by default. These fields are not case sensitive var disabledByDefaultComparer = new DefaultValueValueComparer("Disabled", IgnoreCaseStringsValueComparer.Instance); _comparer.AddComparerOverride("SmartMode1", disabledByDefaultComparer); _comparer.AddComparerOverride("SmartMode2", disabledByDefaultComparer); _comparer.AddComparerOverride("SmartMode3", disabledByDefaultComparer); //http prefix in URLs should be ignored var urlComparer = new DynamicValueComparer( (url1, url2, settings) => url1.Trim('/').Replace(@"http://", string.Empty) == url2.Trim('/').Replace(@"http://", string.Empty)); _comparer.AddComparerOverride("SomeUrl", urlComparer); _comparer.AddComparerOverride("SomeOtherUrl", urlComparer); //DataCompression is Off by default. _comparer.AddComparerOverride("DataCompression", new DefaultValueValueComparer("Off", NulableStringsValueComparer.Instance)); //ProcessTaskTimeout and TotalProcessTimeout fields have default values. _comparer.AddComparerOverride("ProcessTaskTimeout", new DefaultValueValueComparer(100, DefaultValueComparer.Instance)); _comparer.AddComparerOverride("TotalProcessTimeout", new DefaultValueValueComparer(500, DefaultValueComparer.Instance)); ``` ```csharp var settings0Json = LoadJson("Settings0.json"); var settings0 = JsonConvert.DeserializeObject(settings0Json); var settings1Json = LoadJson("Settings1.json"); var settings1 = JsonConvert.DeserializeObject(settings1Json); IEnumerable differences; var isEqual = _comparer.Compare(settings0, settings1, out differences); ``` > Objects are equal ```csharp var settings0Json = LoadJson("Settings0.json"); var settings0 = JsonConvert.DeserializeObject(settings0Json); var settings2Json = LoadJson("Settings2.json"); var settings2 = JsonConvert.DeserializeObject(settings2Json); IEnumerable differences; var isEqual = _comparer.Compare(settings0, settings2, out differences); ``` > Difference: DifferenceType=ValueMismatch, MemberPath='Settings.DataCompression', Value1='On', Value2='Off'. > Difference: DifferenceType=ValueMismatch, MemberPath='Settings.SuperModes.SmartMode1', Value1='Enabled', Value2='Disabled'. > Difference: DifferenceType=ValueMismatch, MemberPath='Timeouts.ProcessTaskTimeout', Value1='100', Value2='200'. > Difference: DifferenceType=ValueMismatch, MemberPath='BackupSettings.BackupIntervalUnit', Value1='Day', Value2='Week'. > Difference: DifferenceType=ValueMismatch, MemberPath='BackupSettings.BackupInterval', Value1='100', Value2='2'. > Difference: DifferenceType=ValueMismatch, MemberPath='Logging.Enabled', Value1='True', Value2='False'. > Difference: DifferenceType=ValueMismatch, MemberPath='Logging.MaximumFileSize', Value1='20MB', Value2='40MB'. > Difference: DifferenceType=ValueMismatch, MemberPath='Logging.Level', Value1='ALL', Value2='ERROR'. ### Example 4: Custom comparer for list #### Challenge This example came from one of the framework users, so it's 100% real life scenario. Compare list of items by content even if counts of items in the lists are different. Use Id property as an identifier. #### Problems By default if counts of items in the lists are different Comparer consider these lists as different and doesn't compere items. #### Solution Solution for this problem is to implement custom Comparer (it should be inherited from AbstractComparer<TypeOfTheList>) and implement comparison logic of comparing lists inside this Comparer. Then implement ComparersFactory (like in Example 2) to return custom Comparer if type equal to IList and use this factory. Classes to compare. ```csharp public class FormulaItem { public long Id { get; set; } public int Delay { get; set; } public string Name { get; set; } public string Instruction { get; set; } } ``` ```csharp public class Formula { public long Id { get; set; } public string Name { get; set; } public IList Items { get; set; } } ``` Custom Comparer implementation ```csharp public class CustomFormulaItemsComparer: AbstractComparer> { public CustomFormulaItemsComparer(ComparisonSettings settings, BaseComparer parentComparer, IComparersFactory factory) : base(settings, parentComparer, factory) { } public override IEnumerable CalculateDifferences(IList obj1, IList obj2) { if (obj1 == null && obj2 == null) { yield break; } if (obj1 == null || obj2 == null) { yield return new Difference("", DefaultValueComparer.ToString(obj1) , DefaultValueComparer.ToString(obj2)); yield break; } if (obj1.Count != obj2.Count) { yield return new Difference("Count", obj1.Count.ToString(), obj2.Count.ToString(), DifferenceTypes.NumberOfElementsMismatch); } foreach (var formulaItem in obj1) { var formulaItem2 = obj2.FirstOrDefault(fi => fi.Id == formulaItem.Id); if (formulaItem2 != null) { var comparer = Factory.GetObjectsComparer(); foreach (var difference in comparer.CalculateDifferences(formulaItem, formulaItem2)) { yield return difference.InsertPath($"[Id={formulaItem.Id}]"); } } } } } ``` Factory ```csharp public class MyComparersFactory : ComparersFactory { public override IComparer GetObjectsComparer(ComparisonSettings settings = null, BaseComparer parentComparer = null) { if (typeof(T) != typeof(IList)) { return base.GetObjectsComparer(settings, parentComparer); } var comparer = new CustomFormulaItemsComparer(settings, parentComparer, this); return (IComparer) comparer; } } ``` Configuring Comparer. ```csharp _factory = new MyComparersFactory(); _comparer = _factory.GetObjectsComparer(); ``` ``` var formula1 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 60, Name = "Item 1", Instruction = "Instruction 1" } } }; var formula2 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 80, Name = "Item One", Instruction = "Instruction One" } } }; var isEqual = _comparer.Compare(formula1, formula2, out var differences); ``` > Difference: DifferenceType=ValueMismatch, MemberPath='Items[Id=1].Delay', Value1='60', Value2='80'. > Difference: DifferenceType=ValueMismatch, MemberPath='Items[Id=1].Name', Value1='Item 1', Value2='Item One'. > Difference: DifferenceType=ValueMismatch, MemberPath='Items[Id=1].Instruction', Value1='Instruction 1', Value2='Instruction One'. ```csharp var formula1 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 60, Name = "Item 1", Instruction = "Instruction 1" } } }; var formula2 = new Formula { Id = 1, Name = "Formula 1", Items = new List { new FormulaItem { Id = 1, Delay = 80, Name = "Item One", Instruction = "Instruction One" }, new FormulaItem { Id = 2, Delay = 30, Name = "Item Two", Instruction = "Instruction Two" } } }; var isEqual = _comparer.Compare(formula1, formula2, out var differences); ``` > Difference: DifferenceType=NumberOfElementsMismatch, MemberPath='Items.Count', Value1='1', Value2='2'. > Difference: DifferenceType=ValueMismatch, MemberPath='Items[Id=1].Delay', Value1='60', Value2='80'. > Difference: DifferenceType=ValueMismatch, MemberPath='Items[Id=1].Name', Value1='Item 1', Value2='Item One'. > Difference: DifferenceType=ValueMismatch, MemberPath='Items[Id=1].Instruction', Value1='Instruction 1', Value2='Instruction One'. ## Contributing Any useful changes are welcomed. Feel free to report any defects or ideas how this framework can be improved. Create an issue, contact me directly or fork the code and submit a pull request!