using System;

using System.Linq;

using System.Reflection;

using static System.Console;

public class Program

{

    public static void Main()

    {

        var m1 = new Klass()

        {

            FieldA = "A",

            FieldB = "Different",

            FieldC = "C",

            FieldD = 100,

            FieldE = "E",

        };

​

        var m2 = new Klass()

        {

            FieldB = "B",

            FieldC = "C",

            FieldD = 5,

            FieldE = "E",

            Complex = new ComplexType { FieldF = "diff" }

        };

​

        var result = m1.Difference(m2);

        WriteLine(result);

    }

}

​

public static class ReflectionExtensions

{

    public static TModel Difference<TModel>(this TModel model1, TModel model2) where TModel : class, new() =>

        Difference(typeof(TModel), model1, model2);

​

    private static TModel Difference<TModel>(Type type, TModel model1, TModel model2) where TModel : class, new()

    {       

        PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);

​

        TModel result = type.GetConstructor(new Type[] { }).Invoke(null) as TModel;

        result = properties.Aggregate(result, (seed, property) =>

        {

            var value1 = model1 is null ? null : property.GetValue(model1);

            var value2 = model2 is null ? null : property.GetValue(model2);

​

            if (!AreEqual(value1, value2))

            {

                // Take the one which is not default.

                var value = IsDefault(value1) ? value2 : value1;

                property.SetValue(seed, value);

            }

​

            return seed;

        });

​

        return result;

    }

    private static bool IsDefault<TValue>(TValue value) =>

        (value?.Equals(default(TValue))) ?? true;

    private static bool AreEqual(object value1, object value2)

    {

        // Add nullchecks for the sake of simplicity

        if (value1 is null && value2 is null) return true;

        if (value1 is null && value2 is not null) return false;

        if (value1 is not null && value2 is null) return false;

​

        // Check special case string

        if (value1 is string str1 && value2 is string str2)

        {

            return str1 == str2;

        }

​

        // Provide the actual type of the property.

        Type type = value1.GetType();

        // Distinguish between primitive types and classes

        return type.IsValueType

            ? value1.Equals(value2)

            : AreEqualClass(type, value1, value2);

    }

    private static bool AreEqualClass<TValue>(Type type, TValue value1, TValue value2) where TValue : class, new()

    {

        TValue difference = Difference(type, value1, value2);

        PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);

        return properties.All(property =>

        {

            var value = property.GetValue(difference);

            return IsDefault(value);

        });

    }

}

​

public class ComplexType

{

    public string FieldF { get; set;  }

    public override string ToString()

    {

        return $"{{ F = {FieldF} }}";

    }

}

​

public class Klass

{

    public string FieldA { get; set; }

    public string FieldB { get; set; }

    public string FieldC { get; set; }

    public int FieldD { get; set; }

    public string FieldE { get; set; }

​

    public ComplexType Complex { get; set; }

    public override string ToString()

    {

        return $"{{ A = {FieldA}, B = {FieldB}, C = {FieldC}, D = {FieldD}, E = {FieldE}, Complex = {Complex}";

    }

}