Trouver des différences de propriété entre deux objets C#

Ce projet sur codeplex vérifie presque n'importe quel type de propriété et peut être personnalisé selon vos besoin.

Vous pouvez regarder Testapi de Microsoft il a une api de comparaison d'objets qui fait des comparaisons profondes. Cela pourrait être exagéré pour vous, mais cela pourrait valoir le coup d'oeil.

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);
}

Vous ne voulez jamais implémenter GetHashCode sur des propriétés mutables (propriétés qui pourraient être modifiées par quelqu'un)-c'est-à-dire des setters non privés.

Imaginez ce scénario:

1. vous mettez une instance de votre objet dans une collection qui utilise GetHashCode() "sous les couvertures" ou directement (Hashtable).
2. Ensuite, quelqu'un change la valeur du champ/propriété que vous avez utilisé dans votre implémentation GetHashCode ().

Devine quoi...votre objet est définitivement perdu dans la collection puisque la collection utilise GetHashCode () pour le trouver! Vous avez effectivement modifié la valeur de hashcode de ce qui a été initialement placé dans la collection. Probablement pas ce que tu voulais.

Voici une version courte de LINQ qui étend l'objet et renvoie une liste de propriétés qui ne sont pas égales:

Utilisation: objet.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; }
        }

    }

Solution Liviu Trifoi: en utilisant la bibliothèque CompareNETObjects. GitHub - package NuGet - Tutoriel.

Je pense que cette méthode est assez soignée, elle évite la répétition ou l'ajout de quoi que ce soit aux classes. Plus ce que vous recherchez?

La seule alternative serait de générer un dictionnaire d'État pour les anciens et les nouveaux objets, et d'écrire une comparaison pour eux. Le code de génération du dictionnaire d'état peut réutiliser toute sérialisation que vous avez pour stocker ces données dans la base de données.

Ma façon de Expression version de compilation de l'arbre. Il devrait être plus rapide que 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; }
}