关于c＃：是否有用于比较集合的内置方法？

Is there a built-in method to compare collections?

我想在我的Equals方法中比较几个集合的内容。我有一个词典和一个IList。有内置的方法可以做到这一点吗？

编辑：
我想比较两个字典和两个IList，所以我认为相等的含义很清楚-如果两个字典包含映射到相同值的相同键，则它们相等。

Enumerable.SequenceEqual

Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer(T).

您不能直接比较列表和字典，但是可以将"字典"中的值列表与列表进行比较

正如其他人所建议并指出的那样，SequenceEqual是顺序敏感的。要解决此问题，您可以按键对字典排序(这是唯一的，因此排序始终是稳定的)，然后使用SequenceEqual。以下表达式检查两个字典是否相等，无论它们的内部顺序如何：

1	dictionary1.OrderBy(kvp => kvp.Key).SequenceEqual(dictionary2.OrderBy(kvp => kvp.Key))

编辑：正如Jeppe Stig Nielsen所指出的，某些对象的IComparer< T >与它们的IEqualityComparer< T >不兼容，从而产生错误的结果。将键与此类对象一起使用时，必须为这些键指定正确的IComparer< T >。例如，对于字符串键(出现此问题)，必须执行以下操作才能获得正确的结果：

1	dictionary1.OrderBy(kvp => kvp.Key, StringComparer.Ordinal).SequenceEqual(dictionary2.OrderBy(kvp => kvp.Key, StringComparer.Ordinal))

除了上面提到的SequenceEqual，

is true if two lists are of equal length and their corresponding
elements compare equal according to a comparer

(它可能是默认的比较器，即重写的Equals())

值得一提的是，在.Net4中，ISet对象上存在SetEquals，
哪一个

ignores the order of elements and any duplicate elements.

因此，如果您希望有一个对象列表，但它们不必按特定顺序排列，请考虑ISet(如HashSet)可能是正确的选择。

看看Enumerable.SequenceEqual方法

1
2
3
4
5

.NET缺少用于比较集合的任何强大工具。我已经开发了一个简单的解决方案，您可以在下面的链接中找到：

http://robertbouillon.com/2010/04/29/comparing-collections-in-net/

这将执行相等比较，而不考虑顺序：

1
2
3

var list1 = new[] {"Bill","Bob","Sally" };
var list2 = new[] {"Bob","Bill","Sally" };
bool isequal = list1.Compare(list2).IsSame;

这将检查是否已添加/删除项目：

1
2
3
4
5
6

var list1 = new[] {"Billy","Bob" };
var list2 = new[] {"Bob","Sally" };
var diff = list1.Compare(list2);
var onlyinlist1 = diff.Removed; //Billy
var onlyinlist2 = diff.Added; //Sally
var inbothlists = diff.Equal; //Bob

这将查看字典中的哪些项目已更改：

1
2
3
4
5
6

这不是直接回答您的问题，但是MS的TestTools和NUnit都可以提供

1	CollectionAssert.AreEquivalent

这几乎可以满足您的需求。

我不知道Enumerable.SequenceEqual方法(您每天都在学习……)，但是我建议使用扩展方法。像这样的东西：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public static bool IsEqual(this List<int> InternalList, List<int> ExternalList)
{
if (InternalList.Count != ExternalList.Count)
{
return false;
}
else
{
for (int i = 0; i < InternalList.Count; i++)
{
if (InternalList[i] != ExternalList[i])
return false;
}
}

return true;

}

有趣的是，花了2秒钟阅读了一下SequenceEqual之后，看来Microsoft已构建了我为您介绍的功能。

对于有序集合(列表，数组)，请使用SequenceEqual

对于HashSet使用SetEquals

对于字典，您可以执行以下操作：

1
2
3
4
5
6
7
8
9
10
11
12
13

namespace System.Collections.Generic {
public static class ExtensionMethods {
public static bool DictionaryEquals<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> d1, IReadOnlyDictionary<TKey, TValue> d2) {
if (object.ReferenceEquals(d1, d2)) return true;
if (d2 is null || d1.Count != d2.Count) return false;
foreach (var (d1key, d1value) in d1) {
if (!d2.TryGetValue(d1key, out TValue d2value)) return false;
if (!d1value.Equals(d2value)) return false;
}
return true;
}
}
}

(更优化的解决方案将使用排序，但这需要IComparable)

这个例子怎么样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

static void Main()
{
// Create a dictionary and add several elements to it.
var dict = new Dictionary<string, int>();
dict.Add("cat", 2);
dict.Add("dog", 3);
dict.Add("x", 4);

// Create another dictionary.
var dict2 = new Dictionary<string, int>();
dict2.Add("cat", 2);
dict2.Add("dog", 3);
dict2.Add("x", 4);

// Test for equality.
bool equal = false;
if (dict.Count == dict2.Count) // Require equal count.
{
equal = true;
foreach (var pair in dict)
{
int value;
if (dict2.TryGetValue(pair.Key, out value))
{
// Require value be equal.
if (value != pair.Value)
{
equal = false;
break;
}
}
else
{
// Require key be present.
equal = false;
break;
}
}
}
Console.WriteLine(equal);
}

礼貌：https：//www.dotnetperls.com/dictionary-equals

要比较集合，您也可以使用LINQ。 Enumerable.Intersect返回所有相等的对。您可以像这样比较两个字典：

1	(dict1.Count == dict2.Count) && dict1.Intersect(dict2).Count() == dict1.Count

需要进行第一次比较，因为dict2可以包含dict1及更高版本中的所有键。

您还可以考虑使用Enumerable.Except和Enumerable.Union导致不同结果的变化。但是可以用来确定集合之间的确切差异。

曾经，现在，也可能不是，至少，我相信。背后的原因是收集平等可能是用户定义的行为。

尽管集合中的元素自然具有顺序，但它们不应具有特定的顺序，这不是比较算法应依赖的元素。假设您有以下两个集合：

1 2	{1, 2, 3, 4} {4, 3, 2, 1}

他们是否相等？您必须知道，但我不知道您的观点。

默认情况下，集合在概念上是无序的，直到算法提供排序规则为止。当您尝试进行分页时，SQL Server将引起您注意的同一件事，它要求您提供排序规则：

https://docs.microsoft.com/en-US/sql/t-sql/queries/select-order-by-clause-transact-sql?view=sql-server-2017

另外两个集合：

1 2	{1, 2, 3, 4} {1, 1, 1, 2, 2, 3, 4}

同样，它们是否相等？你告诉我 ..

集合的元素可重复性在不同的场景中发挥作用，某些集合，例如Dictionary甚至不允许重复的元素。

我相信这些平等是由应用程序定义的，因此该框架并未提供所有可能的实现。

好吧，通常情况下Enumerable.SequenceEqual足够好，但是在以下情况下它返回false：

1
2
3

var a = new Dictionary<String, int> { {"2", 2 }, {"1", 1 }, };
var b = new Dictionary<String, int> { {"1", 1 }, {"2", 2 }, };
Debug.Print("{0}", a.SequenceEqual(b)); // false

我阅读了一些类似这样的问题的答案(您可能会用谷歌搜索它们)以及一般情况下我会用到什么：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public static class CollectionExtensions {
public static bool Represents< T >(this IEnumerable< T > first, IEnumerable< T > second) {
if(object.ReferenceEquals(first, second)) {
return true;
}

if(first is IOrderedEnumerable< T > && second is IOrderedEnumerable< T >) {
return Enumerable.SequenceEqual(first, second);
}

if(first is ICollection< T > && second is ICollection< T >) {
if(first.Count()!=second.Count()) {
return false;
}
}

first=first.OrderBy(x => x.GetHashCode());
second=second.OrderBy(x => x.GetHashCode());
return CollectionExtensions.Represents(first, second);
}
}

这意味着一个集合在其元素中代表另一个集合，包括重复的次数，而不考虑原始顺序。实施注意事项：

GetHashCode()仅用于排序而不是相等；我认为在这种情况下就足够了
Count()不会真正枚举集合，而是直接属于ICollection< T >.Count的属性实现
如果引用相等，那只是鲍里斯

1
2
3
4
5
6
7
8
9
10
11

public bool CompareStringLists(List<string> list1, List<string> list2)
{
if (list1.Count != list2.Count) return false;

foreach(string item in list1)
{
if (!list2.Contains(item)) return false;
}

return true;
}

不。收集框架没有任何平等的概念。如果您考虑一下，则无法比较不是主观的集合。例如，将您的IList与字典进行比较，如果所有键都在IList中，所有值都在IList中还是两个都在IList中，它们是否相等？没有明显的方法来比较这两个集合，而又不知道它们将用于什么用途，因此通用的equals方法毫无意义。

不，因为该框架不知道如何比较列表的内容。

看看这个：

http://blogs.msdn.com/abhinaba/archive/2005/10/11/479537.aspx