Поиск различий свойств между двумя объектами C#

этой проект на codeplex проверяет почти любой тип собственности и может быть настроен по мере необходимости.

вы можете посмотреть на Microsoft Testapi он имеет api сравнения объектов, который делает глубокие сравнения. Это может быть слишком для вас, но это может быть стоит посмотреть.

var comparer = new ObjectComparer(new PublicPropertyObjectGraphFactory());
IEnumerable<ObjectComparisonMismatch> mismatches;
bool result = comparer.Compare(left, right, out mismatches);

foreach (var mismatch in mismatches)
{
    Console.Out.WriteLine("\t'{0}' = '{1}' and '{2}'='{3}' do not match. '{4}'",
        mismatch.LeftObjectNode.Name, mismatch.LeftObjectNode.ObjectValue,
        mismatch.RightObjectNode.Name, mismatch.RightObjectNode.ObjectValue,
        mismatch.MismatchType);
}

вы никогда не захотите реализовать GetHashCode на изменяемых свойствах (свойствах, которые могут быть изменены кем - то)-т. е. не-частных сеттерах.

представьте себе такой сценарий:

1. вы помещаете экземпляр своего объекта в коллекцию, которая использует GetHashCode() "под обложками" или напрямую (Hashtable).
2. затем кто-то изменяет значение поля/свойства, которое вы использовали в своей реализации GetHashCode ().

Угадай что?...ваш объект навсегда потерян в коллекции, так как коллекция использует GetHashCode (), чтобы найти его! Вы эффективно изменили значение хэш-кода из того, что было первоначально помещено в коллекцию. Возможно, не то, что ты хотел.

здесь короткая версия LINQ, которая расширяет объект и возвращает список свойств, которые не равны:

использование: объект.DetailedCompare (objectToCompare);

public static class ObjectExtensions
    {

        public static List<Variance> DetailedCompare<T>(this T val1, T val2)
        {
            var propertyInfo = val1.GetType().GetProperties();
            return propertyInfo.Select(f => new Variance
                {
                    Property = f.Name,
                    ValueA = f.GetValue(val1),
                    ValueB = f.GetValue(val2)
                })
                .Where(v => !v.ValueA.Equals(v.ValueB))
                .ToList();
        }

        public class Variance
        {
            public string Property { get; set; }
            public object ValueA { get; set; }
            public object ValueB { get; set; }
        }

    }

решение Ливиу Трифои: использование библиотеки CompareNETObjects. GitHub -пакета NuGet -учебник.

Я думаю, что этот метод довольно аккуратный, он избегает повторения или добавления чего-либо в классы. Что еще вы ищете?

единственной альтернативой было бы создать государство словарь для старых и новых объектов, и написать сравнение для них. Код для создания словаря состояний может повторно использовать любую сериализацию для хранения этих данных в базе данных.

мой путь Expression версия компиляции дерева. Это должно быстрее, чем PropertyInfo.GetValue.

static class ObjDiffCollector<T>
{
    private delegate DiffEntry DiffDelegate(T x, T y);

    private static readonly IReadOnlyDictionary<string, DiffDelegate> DicDiffDels;

    private static PropertyInfo PropertyOf<TClass, TProperty>(Expression<Func<TClass, TProperty>> selector)
        => (PropertyInfo)((MemberExpression)selector.Body).Member;

    static ObjDiffCollector()
    {
        var expParamX = Expression.Parameter(typeof(T), "x");
        var expParamY = Expression.Parameter(typeof(T), "y");

        var propDrName = PropertyOf((DiffEntry x) => x.Prop);
        var propDrValX = PropertyOf((DiffEntry x) => x.ValX);
        var propDrValY = PropertyOf((DiffEntry x) => x.ValY);

        var dic = new Dictionary<string, DiffDelegate>();

        var props = typeof(T).GetProperties();
        foreach (var info in props)
        {
            var expValX = Expression.MakeMemberAccess(expParamX, info);
            var expValY = Expression.MakeMemberAccess(expParamY, info);

            var expEq = Expression.Equal(expValX, expValY);

            var expNewEntry = Expression.New(typeof(DiffEntry));
            var expMemberInitEntry = Expression.MemberInit(expNewEntry,
                Expression.Bind(propDrName, Expression.Constant(info.Name)),
                Expression.Bind(propDrValX, Expression.Convert(expValX, typeof(object))),
                Expression.Bind(propDrValY, Expression.Convert(expValY, typeof(object)))
            );

            var expReturn = Expression.Condition(expEq
                , Expression.Convert(Expression.Constant(null), typeof(DiffEntry))
                , expMemberInitEntry);

            var expLambda = Expression.Lambda<DiffDelegate>(expReturn, expParamX, expParamY);

            var compiled = expLambda.Compile();

            dic[info.Name] = compiled;
        }

        DicDiffDels = dic;
    }

    public static DiffEntry[] Diff(T x, T y)
    {
        var list = new List<DiffEntry>(DicDiffDels.Count);
        foreach (var pair in DicDiffDels)
        {
            var r = pair.Value(x, y);
            if (r != null) list.Add(r);
        }
        return list.ToArray();
    }
}

class DiffEntry
{
    public string Prop { get; set; }
    public object ValX { get; set; }
    public object ValY { get; set; }
}