檢查兩個List <T>是否相等的最快方法

Question

我有兩個列表

ListA<Emp>和ListB<Emp>都有1000條記錄。

Emp是Employee Class的對象。 以下是我的Employee課程

public class Employee
{
    int ID = 0;
    string Name = String.Empty;
    string Dept = String.Empty;
    string Address = String.Empty;
    int Age = 0;
    string Email = String.Empty;
}

我想驗證兩個列表是否相等。 Emp對象可以按不同順序放置。 此外，可能有幾個Emp對象在列表中具有完全相同的信息。 我也必須核實這些。

我嘗試對列表進行排序並使用SequenceEqual進行比較

Enumerable.SequenceEqual(ListA.OrderBy(s => s), ListB.OrderBy(s => s)

我收到了以下錯誤

At least one object must implement IComparable.
Exception Stack trace is as below 

   at System.Collections.Comparer.Compare(Object a, Object b)
   at System.Collections.Generic.ObjectComparer`1.Compare(T x, T y)
   at System.Linq.EnumerableSorter`2.CompareKeys(Int32 index1, Int32 index2)
   at System.Linq.EnumerableSorter`1.QuickSort(Int32[] map, Int32 left, Int32 right)
   at System.Linq.EnumerableSorter`1.Sort(TElement[] elements, Int32 count)
   at System.Linq.OrderedEnumerable`1.<GetEnumerator>d__0.MoveNext()
   at System.Linq.Enumerable.SequenceEqual[TSource](IEnumerable`1 first, IEnumerable`1 second, IEqualityComparer`1 comparer)
   at System.Linq.Enumerable.SequenceEqual[TSource](IEnumerable`1 first, IEnumerable`1 second)

我該如何實現呢？ 如果你們能夠以最快的方式為我提供這樣做會更好，因為List中的對象數量可能會增加到1000萬。 謝謝你的幫助 ！

編輯：每個員工必須在兩個列表中，順序無關緊要。 但是，如果ListA包含相同的雇員對象5次（這意味着一些重復的條目），並且ListB包含雇員對象4次，則ListA和ListB不相等。

Answer 1

您可以將SequenceEqual與自定義IEqualityComparer<Employee> ：

class EmployeeComparer : IEqualityComparer<Employee>
{
    public bool Equals(Employee x, Employee y)
    {
        if (x == null || y == null) return false;

        bool equals = x.ID==y.ID && x.Name == y.Name && x.Dept == y.Dept 
            && x.Address == y.Address && x.Age == y.Age && x.Email == y.Email;
        return equals;
    }

    public int GetHashCode(Employee obj)
    {
        if (obj == null) return int.MinValue;

        int hash = 19;
        hash = hash + obj.ID.GetHashCode();
        hash = hash + obj.Name.GetHashCode();
        hash = hash + obj.Dept.GetHashCode();
        hash = hash + obj.Address.GetHashCode();
        hash = hash + obj.Age.GetHashCode();
        hash = hash + obj.Email.GetHashCode();
        return hash;
    }
}

現在它很簡單：

listA.SequenceEqual(ListB, new EmployeeComparer());

如果訂單不重要且您只想知道所有員工是否都在兩個列表中，您可以使用HashSet<Employee>.SetEquals來確定兩個列表是否包含相同的人員：

var empComparer =  new EmployeeComparer();
bool bothEqual = new HashSet<Employee>(ListA, empComparer)
      .SetEquals(new HashSet<Employee>(ListB, empComparer));

Answer 2

最好的復雜性是O（N）使用HashSet實現之后：

實現GetHashCode和Equals的類：

public class Employee
{
    public int ID = 0;
    public string Name = String.Empty;
    public string Dept = String.Empty;
    public string Address = String.Empty;
    public int Age = 0;
    public string Email = String.Empty;

    public override int GetHashCode()
    {
        return
            ID.GetHashCode() ^
            (Name ?? String.Empty).GetHashCode() ^
            (Dept ?? String.Empty).GetHashCode() ^
            (Address ?? String.Empty).GetHashCode() ^
            Age.GetHashCode() ^
            (Email ?? String.Empty).GetHashCode()
            ;
    }
    public override bool Equals(object obj)
    {
        Employee other = obj as Employee;
        if (obj == null)
            return false;

        return ID == other.ID &&
                Name == other.Name &&
                Dept == other.Dept &&
                Address == other.Address &&
                Age == other.Age &&
                Email == other.Email;
    }
}

比較列表的功能：

public static bool CompareLists(List<Employee> list1, List<Employee> list2)
{
    if (list1 == null || list2 == null)
        return list1 == list2;

    if (list1.Count != list2.Count)
        return false;
    Dictionary<Employee, int> hash = new Dictionary<Employee, int>();
    foreach (Employee employee in list1)
    {
        if (hash.ContainsKey(employee))
        {
            hash[employee]++;
        }
        else
        {
            hash.Add(employee, 1);
        }
    }

    foreach (Employee employee in list2)
    {
        if (!hash.ContainsKey(employee) || hash[employee] == 0)
        {
            return false;
        }
        hash[employee]--;
    }

    return true;
}

Answer 3

如果列表中的數字將變得非常大（10M），您可能不得不考慮查找的並行化以獲得可接受的查詢時間。

考慮使用PLINQ 。

你對'平等'的意思更清楚一點是好的。 等價檢查有多復雜？ 您是在檢查對象是否相同或者對象值是否相同？

另一個考慮是這個; 如果元素的數量變得很大，你能考慮將這個檢查從.NET轉移到你的數據庫 - 也許作為一個存儲過程？ 您可能會發現它在那里執行效率更高。

Answer 4

將列表縮減為標量類型：int，string，....

L1.Select(x => x.K).ToArray()

使用except方法

L1.Select(x => x.K).ToArray().Except(L1.Select(x => x.K).ToArray())

如果結果集的計數為0，則List等於

L1.Select(x => x.K).ToArray().Except(L1.Select(x => x.K).ToArray()).Count()

全部一起

public class Program {
    public static void Main(String[] args) {
        List<O> L1 = new List<O>{
            new O {K = 1, V = "abcd"},
            new O {K = 2, V = "efgh"}
        };
        List<O> L2 = new List<O>{
            new O {K = 1, V = "abcd"}
        };
        List<O> L3 = new List<O>{
            new O {K = 1, V = "abcd"},
            new O {K = 3, V = "ijkl"}
        };
        List<O> L4 = new List<O>{
            new O {K = 2, V = "efgh"},
            new O {K = 1, V = "abcd"}

        };

        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L1.Select(x => x.K).ToArray()).Count());
        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L2.Select(x => x.K).ToArray()).Count());
        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L3.Select(x => x.K).ToArray()).Count());
        Console.WriteLine(L1.Select(x => x.K).ToArray().Except(L4.Select(x => x.K).ToArray()).Count());

    }
} 

public class O {
    public int K { get; set; }
    public String V { get; set; }
}

Answer 5

究竟是什么意思。
在Employee類上實現IComparable
還需要覆蓋Equals
由於可能會對GetHashCode進行大量調用而將其保存並僅計算更改。
經測試

IComparable接口

public MainWindow()
{
    InitializeComponent();
    List<Person> PLa = new List<Person>();
    List<Person> PLb = new List<Person>();

    PLa.Add(new Person { Age = 3, Name = "Jim"});
    PLa.Add(new Person { Age = 2, Name = "Jimmmy" });
    PLa.Add(new Person { Age = 1, Name = "Jim" });

    PLb.Add(new Person { Age = 1, Name = "Jim" });
    PLb.Add(new Person { Age = 3, Name = "Jim" });
    PLb.Add(new Person { Age = 2, Name = "Jimmmy" });

    System.Diagnostics.Debug.WriteLine(ListSameIgnoreOrder(PLa, PLb));

}

public bool ListSameIgnoreOrder(List<Person> PLa, List<Person> PLb)
{
    if (PLa.Count != PLb.Count) return false;
    //PLa.Sort();
    //PLb.Sort();
    return Enumerable.SequenceEqual(PLa.OrderBy(s => s), PLb.OrderBy(s => s));
    //for (int i = 0; i < PLa.Count; i++)
    //{
    //    System.Diagnostics.Debug.WriteLine(
    //        PLa[i].Age.ToString() + " " + PLb[i].Age.ToString() + " " +
    //        PLa[i].Name + " " + PLb[i].Name);
    //    if (!PLa[i].Equals(PLb[i])) return false;
    //}
    //return true;
}

public class Person : object, IComparable
{
    private int age = 0;
    private string name = string.Empty;
    private int hash;

    public int Age
    {
        get { return age; }
        set 
        {
            if (age == value) return;
            age = value;
            CalcHash();
        }
    }
    public string Name
    {
        get { return name; }
        set 
        { 
            if (name == value) return;
            name = value;
            CalcHash();
        }
    }

    public override bool Equals(Object obj)
    {
        //Check for null and compare run-time types.
        if (obj == null || !(obj is Person)) return false;
        Person f = (Person)obj;
        if (f.Age != this.Age) return false;
        return (string.Compare(f.name, this.name) == 0);
    }

    private void CalcHash()
    {
        hash = Age.GetHashCode() ^
            (Name ?? String.Empty).GetHashCode();
    }

    public override int GetHashCode()
    {
        return hash;
        //return age ^ name.GetHashCode();
    }

    public int CompareTo(object obj)
    {
        if (obj == null) return 1;

        Person otherPerson = obj as Person;
        if (otherPerson != null)
        {
            if (otherPerson.Age > this.Age) return -1;
            if (otherPerson.Age < this.Age) return 1;
            // compare all properties like above
            return string.Compare(otherPerson.name, this.name);
        }
        else
            throw new ArgumentException("Object is not a Person");
    }
    public Person() { CalcHash(); }
}

Answer 6

這有效。

public bool EqualList(Dictionary<int, string> a, Dictionary<int, string> b)
{
    if (a.Count == b.Count)
    {
        bool rs = false;
        foreach (var i in a)
        {
            if (b.ContainsKey(i.Key))
            {
                rs = true;
            }
            else
            {
                rs = false;
                break;
            }
        }
        return rs;
    }
    else
    {
        return false;
    }

用法：

if(EqualList(List<A>.ToDictionary(k => k.Key, k => k.Value), List<B>.ToDictionary(k => k.Key, k => k.Value)){

}else{

}