using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Runtime.CompilerServices;

​

public class Program

{

    public static void Main(string[] args)

    {

        var test1 = new Test

        {

            Y = 10,

            Foo = new Foo

            {

                X = 1

            }

        };

​

        var test2 = new Test

        {

            Y = 10,

            Foo = new Foo

            {

                X = 1

            }

        };

​

        var test3 = new Test

        {

            Y = 9,

            Foo = new Foo

            {

                X = 1

            }

        };

​

        var l1 = new List<string>

        {

            "Hello",

            "World"

        };

        var l2 = new List<string>

        {

            "Hello",

            "World"

        };

​

        var comparer1 = new ValueEqualityComparer<List<string>>();

        Console.WriteLine(comparer1.Equals(l1, l2)); // True

​

        var comparer2 = new ValueEqualityComparer<Test>();

        Console.WriteLine(comparer2.Equals(test1, test2)); // True

        Console.WriteLine(comparer2.Equals(test2, test3)); // False

​

        var testList1 = new List<Test> {test1, test2};

        var testList2 = new List<Test> {test1, test2};

        var testList3 = new List<Test> {test2, test3};

​

​

        var comparer3 = new ValueEqualityComparer<List<Test>>();

        Console.WriteLine(comparer3.Equals(testList1, testList2)); // True

        Console.WriteLine(comparer3.Equals(testList2, testList3)); // False

    }

​

    public class Foo

    {

        public int X { get; set; }

    }

​

    public class Test

    {

        public int Y { get; set; }

​

        public Foo Foo { get; set; }

    }

}

​

public class ValueEqualityComparer<T> : IEqualityComparer<T>

{

    private readonly Type _enumerableElementType;

    private readonly bool _isEnumerable;

    private readonly bool _isPrimitiveOrString;

    public ValueEqualityComparer()

    {

        var type = typeof(T);

        _isPrimitiveOrString = IsPrimitiveOrString(type);

​

        // Only check if it's an enumerable,

        // if the current type to compare is not a primitive or string

        if (!_isPrimitiveOrString)

            (_isEnumerable, _enumerableElementType) = IsEnumerableAndElementType(type);

    }

​

    public bool Equals(T left, T right)

    {

        if (_isPrimitiveOrString)

            return left?.Equals(right) ?? false;

​

        if (_isEnumerable)

        {

            // Make generic ValueEqualityComparer type for type of element of enumerable and construct it

            // Possibly cache this

            var elementComparer = typeof(ValueEqualityComparer<>).MakeGenericType(_enumerableElementType)

                .GetConstructor(new Type[] { })?.Invoke(null);

​

            // Get the SequenceEqual method and make it generic for our element type

            // SequenceEqual methods may also be cached for better performance

            var sequenceEquals = typeof(Enumerable).Assembly.GetTypes()

                .Where(assemblyType =>

                    assemblyType.IsSealed && !assemblyType.IsGenericType && !assemblyType.IsNested)

                .SelectMany(assemblyType => assemblyType.GetMethods(BindingFlags.Static | BindingFlags.Public),

                    (assemblyType, method) => new {assemblyType, method})

                .Where(x => x.method.IsDefined(typeof(ExtensionAttribute), false))

                .First(x => x.method.Name == nameof(Enumerable.SequenceEqual) &&

                            x.method.GetParameters().Length == 3)

                .method

                .MakeGenericMethod(_enumerableElementType);

​

            // This is basically like calling left.SequenceEqual(right, elementComparer);

            // Cast to bool, as SequenceEqual returns a bool

            return (bool) sequenceEquals.Invoke(null, new[] {left, right, elementComparer});

        }

​

        // T is not an Enumerable, and not a primitive or a string, so get all public instance properties and compare them

        // We ignore private and static properties here

        var properties = typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public);

        foreach (var property in properties)

        {

            // Get the values of left and right property

            var leftProp = property.GetValue(left);

            var rightProp = property.GetValue(right);

​

            var propComparerType = typeof(ValueEqualityComparer<>).MakeGenericType(property.PropertyType);

            var propComparer = propComparerType.GetConstructor(new Type[] { })?.Invoke(null);

​

            var equalsMethod = propComparerType.GetMethod(nameof(Equals),

                new[] {property.PropertyType, property.PropertyType});

​

            if (equalsMethod == null)

                continue;

​

            // If any of the properties don't equal one another, return false early

            if (!(bool) equalsMethod.Invoke(propComparer, new[] {leftProp, rightProp}))

                return false;

        }

​

        return true;

    }

​

    public int GetHashCode(T x)

    {

        return Tuple.Create(_isEnumerable, _enumerableElementType, _isPrimitiveOrString)

            .GetHashCode();

    }

​

    private static bool IsPrimitiveOrString(Type t)

    {

        return t.IsPrimitive || t == typeof(string);

    }

​

    private static (bool, Type) IsEnumerableAndElementType(Type t)

    {

        var enumerableType = t.GetInterfaces()

            .FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IEnumerable<>));

​

        return (enumerableType != null, enumerableType?.GetGenericArguments().Single());

    }

}