Diferrence嵌套值

我有一个特定类型的变量，为他们的类是：Diferrence嵌套值

public class User 
{ 
    public int? Id { get; set; } 
    public string Password { get; set; } 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 
    public string Email { get; set; } 
    public List<AccessibleSite> Sites { get; set; } 
} 


public class AccessibleSite 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public List<Role> Roles { get; set; } 
    public bool IsChecked { get; set; } 
} 


public class Role 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    public bool IsChecked { get; set; } 
    public string UserFriendlyName { get; set; } 
}

用户可以具有在他许多AccessibleSite并且每个站点有关联的Role列表它。

User类型有两个对象。我需要找到两个列表之间的区别。

到目前为止我写的代码只是比较正确的非List对象。

static class extentions 
{ 
    public static List<Variance> DetailedCompare<T>(this T val1, T val2) 
    { 
     List<Variance> variances = new List<Variance>(); 
     List<FieldInfo> fi = val1.GetType().GetRuntimeFields().ToList<FieldInfo>(); 
    foreach (FieldInfo f in fi) 
    { 
     Variance v = new Variance(); 
     v.Prop = f.Name; 
     v.valA = f.GetValue(val1); 
     v.valB = f.GetValue(val2); 
     if (v.valA is System.Collections.IList && v.valA.GetType().IsGenericType) 
     { 
      foreach (var listItem in v.valA.DetailedCompare(v.valB)) 
      { 
       variances.Add(listItem); 
      } 

     } 
     else 
     { 
      if ((v.valA != null && v.valB != null) && !v.valA.Equals(v.valB)) 
       variances.Add(v); 
     } 

    } 
    return variances; 
} 



class Variance 
{ 
    public string Prop { get; set; } 
    public object valA { get; set; } 
    public object valB { get; set; } 

    public string ChangedFromText 
    { 
    get 
    { 
     return "value of " + Prop + " has changed from " + valA + " to " + valB; 
    } 
}

列表中的项目需要在ID.if的基础上进行比较，如果东西已经改变或没有改变。

我看了下面的solution，但它需要我创建两个不同的类，每个类都用于AccessibleSite和Roles。有没有什么办法可以只使用一种解决方案来编写它。递归可能？ TIA

来源

2015-08-19 SJMan

列表中项目的顺序是否显着？对解决方案产生重大影响！ –

我没有得到问题。我在第一个对象中找到AccessibleSite Id = 1。在用户的第二个对象中，我找到具有相同ID的可访问站点，然后比较AccessibleSite的其他值。与角色对象相同 – SJMan

这样的解决方案非常复杂。

这是我试过的未经测试的解决方案。我会留给你测试和调整它：

该类属性用于指定应将类的哪个字段或属性视为该类实例的Id值。

[AttributeUsage(AttributeTargets.Class)] 
public class IdPropertyAttribute : Attribute 
{ 
    public string IdProperty { get; private set; } 
    public IdPropertyAttribute(string idProperty) { this.IdProperty = idProperty; } 
}

的TExtensions类包含两个扩展方法和多个支承用以反射和两个对象图之间分析的值的方法。

public static class TExtensions 
{ 

    public static Variance DetailedCompare<T>(this T val1, T val2) 
    { 
     return val1.DetailedCompare(val2, null); 
    } 

    public static Variance DetailedCompare<T>(this T val1, T val2, string fieldName) 
    { 
     return typeof(IEnumerable).IsAssignableFrom(typeof(T)) 
       ? TExtensions.enumerableCompare(val1, val2, fieldName) 
       : typeof(T).IsPrimitive 
        ? TExtensions.valueCompare(val1, val2, fieldName) 
        : TExtensions.objectCompare(val1, val2, fieldName); 
    } 

    private static Variance valueCompare<T>(T val1, T val2, string fieldName) 
    { 
     return val1 != null && val2 != null && !val1.Equals(val2) 
       ? new Variance.ValueVariance<T>() { Prop = fieldName??"<root>", valA = val1, valB = val2 } 
       : null; 
    } 

    private static Variance objectCompare<T>(T val1, T val2, string fieldName) 
    { 
     var variance = new Variance.EnumerableVariance() {Prop = fieldName}; 

     List<FieldInfo> fi = val1.GetType().GetRuntimeFields().ToList<FieldInfo>(); 
     foreach (FieldInfo f in fi) 
     { 
      var subVariance = f.GetValue(val1).DetailedCompare(f.GetValue(val2), f.Name); 

      if (subVariance != null) variance.variances.Add(subVariance); 
     } 
     return variance; 
    } 

    private static Variance enumerableCompare<T>(T val1, T val2, string fieldName) 
    { 
     return typeof(IEnumerable<>).IsAssignableFrom(typeof(T)) 
       ? TExtensions.homogeneousEnumerableCompare<T>(val1, val2, fieldName) 
       : TExtensions.heterogeneousEnumerableCompare<T>(val1, val2, fieldName); 
    } 

    private static Variance heterogeneousEnumerableCompare<T>(T val1, T val2, string fieldName) 
    { 
     throw new NotImplementedException(); 
    } 

    private static Variance homogeneousEnumerableCompare<T>(T val1, T val2, string fieldName) 
    { 
     var subType  = typeof(T).GetGenericArguments()[0]; 
     return typeof(KeyValuePair<,>).IsAssignableFrom(subType) 
       ? TExtensions.homogeneousKeyValueEnumerableCompare(subType, val1, val2, fieldName) 
       : subType.IsPrimitive 
        ? homogeneousValueEnumerableCompare(subType, val1, val2, fieldName) 
        : homogeneousObjectEnumerableCompare(subType, val1, val2, fieldName); 
    } 

    private static Variance homogeneousObjectEnumerableCompare<T>(Type subType, T val1, T val2, string fieldName) 
    { 
     var subMethod = typeof(TExtensions) 
          .GetMethod("typedHomogeneousObjectEnumerableCompare", BindingFlags.Static, null, new []{typeof(T), typeof(T), typeof(String)}, null) 
          .MakeGenericMethod(new []{typeof(T), subType}); 

     return (Variance) subMethod.Invoke(null, new object[] {val1, val2, fieldName}); 
    } 

    private static Variance typedHomogeneousObjectEnumerableCompare<T, TSubType>(T val1, T val2, string fieldName) 
    { 
     var idAttribute = typeof(TSubType).GetCustomAttribute<IdPropertyAttribute>(true); 
     return idAttribute == null 
       ? TExtensions.keyLessTypedHomogeneousObjectEnumerableCompare<T, TSubType>(val1, val2, fieldName) 
       : TExtensions.keyedTypedHomogeneousObjectEnumerableCompare<T, TSubType>(idAttribute, val1, val2, fieldName); 
    } 

    private static Variance keyLessTypedHomogeneousObjectEnumerableCompare<T, TSubType>(T val1, T val2, string fieldName) 
    { 
     var list1 = (IEnumerable<TSubType>) val1; 
     var list2 = (IEnumerable<TSubType>) val2; 
     return list1.Count() != list2.Count() 
       ? new Variance.KeylessObjectEnumerableVariance() { Prop = fieldName, listACount = list1.Count(), listBCount = list2.Count() } 
       : null; 
    } 

    private static Variance keyedTypedHomogeneousObjectEnumerableCompare<T, TSubType>(IdPropertyAttribute idAttribute, T val1, T val2, string fieldName) 
    { 
     var idMember = typeof(TSubType).GetMember(idAttribute.IdProperty).FirstOrDefault(); 
     if (idMember == null) throw new IdMemberNotFoundException(idAttribute.IdProperty, typeof(TSubType).FullName); 

     var subMethod = typeof(TExtensions) 
          .GetMethod("subTypedKeyedTypedHomogeneousObjectEnumerableCompare", BindingFlags.Static, null, new []{typeof(T), typeof(T), typeof(String)}, null) 
          .MakeGenericMethod(new []{typeof(T), typeof(TSubType), (idMember is PropertyInfo ? ((PropertyInfo) idMember).PropertyType : ((FieldInfo) idMember).FieldType)}); 

     return (Variance) subMethod.Invoke(null, new object[] {val1, val2, fieldName, idMember}); 
    } 

    private static Variance subTypedKeyedTypedHomogeneousObjectEnumerableCompare<T, TSubType, TSubTypeKey>(T val1, T val2, string fieldName, MemberInfo idMember) 
    { 
     return subTypedKeyedTypedHomogeneousObjectEnumerableCompareWithKeyFunc<T, TSubType, TSubTypeKey> 
       (
        val1, 
        val2, 
        fieldName, 
        idMember is PropertyInfo 
        ? new Func<TSubType, TSubTypeKey>(item=>(TSubTypeKey) ((PropertyInfo) idMember).GetValue(item)) 
        : item=>(TSubTypeKey) ((FieldInfo) idMember).GetValue(item) 
       ); 
    } 

    private static Variance subTypedKeyedTypedHomogeneousObjectEnumerableCompareWithKeyFunc<T, TSubType, TSubTypeKey>(T val1, T val2, string fieldName, Func<TSubType, TSubTypeKey> getKey) 
    { 
     var set1  = ((IEnumerable<TSubType>) val1).ToDictionary(a=>getKey(a)); 
     var set2  = ((IEnumerable<TSubType>) val2).ToDictionary(a=>getKey(a)); 

     return TExtensions.DictionaryCompare<TSubTypeKey, TSubType>(set1, set2, fieldName); 
    } 

    private static Variance homogeneousValueEnumerableCompare<T>(Type subType, T val1, T val2, string fieldName) 
    { 
     var subMethod = typeof(TExtensions) 
          .GetMethod("typedHomogeneousValueEnumerableCompare", BindingFlags.Static, null, new []{typeof(T), typeof(T), typeof(String)}, null) 
          .MakeGenericMethod(new []{typeof(T), subType}); 

     return (Variance) subMethod.Invoke(null, new object[] {val1, val2, fieldName}); 
    } 

    private static Variance typedHomogeneousValueEnumerableCompare<T, TSubType>(T val1, T val2, string fieldName) 
    { 
     var variance = new Variance.EnumerableVariance(); 
     var list1  = ((IEnumerable<TSubType>) val1).ToList(); 
     var list2  = ((IEnumerable<TSubType>) val1).ToList(); 

     foreach(var item in list1) if (!list2.Contains(item)) variance.variances.Add(new Variance.ValueRemovedVariance<TSubType>() {Prop = fieldName, value = item}); 
     foreach(var item in list2) if (!list1.Contains(item)) variance.variances.Add(new Variance.ValueAddedVariance<TSubType>() {Prop = fieldName, value = item}); 

     return variance; 
    } 

    private static Variance homogeneousKeyValueEnumerableCompare<T>(Type subType, T val1, T val2, string fieldName) 
    { 
     var keyType  = subType.GetGenericArguments()[0]; 
     var valueType = subType.GetGenericArguments()[1]; 
     var subMethod = typeof(TExtensions) 
          .GetMethod("typedHomogeneousKeyValueEnumerableCompare", BindingFlags.Static, null, new []{typeof(T), typeof(T), typeof(String)}, null) 
          .MakeGenericMethod(new []{typeof(T), keyType, valueType}); 

     return (Variance) subMethod.Invoke(null, new object[] {val1, val2, fieldName}); 
    } 

    private static Variance typedHomogeneousKeyValueEnumerableCompare<T, TSubTypeKey, TSubTypeValue>(T val1, T val2, string fieldName) 
    { 
     var set1  = ((IEnumerable<KeyValuePair<TSubTypeKey, TSubTypeValue>>) val1).ToDictionary(a=>a.Key, a=>a.Value); 
     var set2  = ((IEnumerable<KeyValuePair<TSubTypeKey, TSubTypeValue>>) val2).ToDictionary(a=>a.Key, a=>a.Value); 

     return TExtensions.DictionaryCompare<TSubTypeKey, TSubTypeValue>(set1, set2, fieldName); 
    } 

    private static Variance DictionaryCompare<TSubTypeKey, TSubTypeValue>(Dictionary<TSubTypeKey, TSubTypeValue> set1, Dictionary<TSubTypeKey, TSubTypeValue> set2, string fieldName) 
    { 
     var variance = new Variance.EnumerableVariance(); 

     foreach(var key in set1.Keys) 
     { 
      var subVariance = !set2.ContainsKey(key) 
           ? new Variance.KeyedObjectRemovedVariance<TSubTypeKey>() {Prop = fieldName, key = key} 
           : set1[key].DetailedCompare(set2[key], fieldName + "[" + key.ToString() + "]"); 

      if (subVariance != null) variance.variances.Add(subVariance); 
     } 

     foreach(var key in set2.Keys) if (!set1.ContainsKey(key)) variance.variances.Add(new Variance.KeyedObjectRemovedVariance<TSubTypeKey>() {Prop = fieldName, key = key}); 

     return variance; 
    } 

}

需要此异常，以指示类已被装饰一IdAttribute，但在阶级分析过程中未发现指定的字段或属性。

public class IdMemberNotFoundException : ApplicationException 
{ 
    public IdMemberNotFoundException(string memberName, string typeName) : base(memberName + " was not found in type " + typeName + ".") {} 
}

方差类已被细分为一个基类与几个子类来表示的不同类型的可发生方差。

你可以差异包括：

两个原始值不同。
第二个列表中缺少一个异构列表中的值项目。
在第二个列表中存在的一个异构中缺失值项目。
第二个列表中缺少一个异构列表中的键控对象项。
在第二个列表中存在一个异构的键控对象项缺失。
两个异构列表之间匹配的对象项有差异。
第二个列表中缺少一个同义列表中的值项目。
在第二个列表中存在的一个齐次中缺少值项目。
第二个列表中缺少一个齐次列表中的键控对象项。
在第二个列表中存在的一个同类中缺少键控对象项目。
在两个同类列表之间匹配的对象项有差异。
两个对象项具有方差

上面的代码应该有希望解决这些差异。您可能会发现其他情况。希望这给你一个很好的起点。

来源

2015-08-19 16:56:46

Diferrence嵌套值

回答

相关问题