Question

我有两个ObservableCollection<Model>，每个模型有10个属性，并且在开始的两个集合中大约有30个对象。它们基本上是这样工作的：最初在两个OC中都保存了相同的对象，其中一个是原始的，另一个是发生变化的地方。基本上，我需要第一个，看看是否已经进行了更改以比较值。到目前为止，我已经提出了

list1.SequenceEquals(list2);

但这仅在我添加新对象时有效，它无法识别实际属性中的更改。有没有一种快速的方法可以做到这一点，或者我需要为每个对象做foreach并逐个比较各个属性？因为可能有超过30个对象来比较值。感谢。

Answer 1

我认为你可以比较他们定义自定义IEqualityComparer<T>，并使用支持自定义比较器的IEnumerable.SequenceEquals重载：Enumerable.SequenceEqual<TSource> Method (IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)有关此问题的更多信息：http://msdn.microsoft.com/it-it/library/bb342073(v=vs.110).aspx

我会在这里发布一个使用示例，以防它丢失：

以下是定义IEqualityComparer<T>

的方法

public class Product
{
    public string Name { get; set; }
    public int Code { get; set; }
}

// Custom comparer for the Product class
class ProductComparer : IEqualityComparer<Product>
{
    // Products are equal if their names and product numbers are equal.
    public bool Equals(Product x, Product y)
    {

        //Check whether the compared objects reference the same data.
        if (Object.ReferenceEquals(x, y)) return true;

        //Check whether any of the compared objects is null.
        if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
            return false;

        //Check whether the products' properties are equal.
        return x.Code == y.Code && x.Name == y.Name;
    }

    // If Equals() returns true for a pair of objects 
    // then GetHashCode() must return the same value for these objects.

    public int GetHashCode(Product product)
    {
        //Check whether the object is null
        if (Object.ReferenceEquals(product, null)) return 0;

        //Get hash code for the Name field if it is not null.
        int hashProductName = product.Name == null ? 0 : product.Name.GetHashCode();

        //Get hash code for the Code field.
        int hashProductCode = product.Code.GetHashCode();

        //Calculate the hash code for the product.
        return hashProductName ^ hashProductCode;
    }

}

以下是如何使用它：

    Product[] storeA = { new Product { Name = "apple", Code = 9 }, 
                           new Product { Name = "orange", Code = 4 } };

    Product[] storeB = { new Product { Name = "apple", Code = 9 }, 
                           new Product { Name = "orange", Code = 4 } };

    bool equalAB = storeA.SequenceEqual(storeB, new ProductComparer());

    Console.WriteLine("Equal? " + equalAB);

    /*
        This code produces the following output:

        Equal? True
    */

Answer 2

是否可以通过快速方式完成此操作，或者我需要为每个对象执行foreach并逐个比较各个属性？

如果快速＆＃34;快速＆＃34;你的意思是＆＃34;表演＆＃34;那么比较property-by属性可能是最快的方法。如果通过＆＃34; fast＆＃34;你是说＆＃34;写的代码少了＃34;然后你可以使用反射循环遍历属性并比较每个项目的值。

请注意，您可能会花更多时间研究，编写和调试您只需手动编码属性比较的反射算法。

使用内置Linq方法的一种简单方法是定义一个IEqualityComparer<Model>来定义两个Model对象的相等性：

class ModelEqualityComparer : IEqualityComparer<Model>
{

    public bool Equals(Model m1, Model m2)
    {

        if(m1 == null || 2. == null)
            return false;

        if (m1.Prop1 == m2.Prop1 
         && m1.Prop2 == m2.Prop2
         && m1.Prop3 == m2.Prop3
            ...
           )
        {
            return true;
        }
        else
        {
            return false;
        }
    }


    public int GetHashCode(Model m)
    {
        int hCode = m.Prop1.GetHashCode();
        hCode = hCode * 23 + ^ m.Prop2.GetHashCode();
        hCode = hCode * 23 + ^ m.Prop32.GetHashCode();
        ...

        return hCode;
    }

}

比较两个列表中的对象值

2 个答案: