检查一个 IEnumerable 是否包含另一个 IEnumerable 的所有元素

Question

在比较两个集合中每个元素的字段/属性时，确定一个 IEnumerable 是否包含另一个 IEnumerable 的所有元素的最快方法是什么？

---

public class Item
{
    public string Value;

    public Item(string value)
    {
        Value = value;
    }
}

//example usage

Item[] List1 = {new Item("1"),new Item("a")};
Item[] List2 = {new Item("a"),new Item("b"),new Item("c"),new Item("1")};

bool Contains(IEnumerable<Item> list1, IEnumerable<Item>, list2)
{
    var list1Values = list1.Select(item => item.Value);
    var list2Values = list2.Select(item => item.Value);

    return //are ALL of list1Values in list2Values?
}

Contains(List1,List2) // should return true
Contains(List2,List1) // should return false

Answer 1

没有“快速方法”可以做到这一点，除非您跟踪和维护确定一个集合中的所有值是否包含在另一个集合中的某种状态。如果你只有IEnumerable<T> 可以对抗，我会使用Intersect。

var allOfList1IsInList2 = list1.Intersect(list2).Count() == list1.Count();

这样的表现应该是非常合理的，因为Intersect() 只会对每个列表进行一次枚举。此外，如果基础类型是 ICollection<T> 而不仅仅是 IEnumerable<T>，则对 Count() 的第二次调用将是最佳的。

Answer 2

您也可以使用 except 从第一个列表中删除第二个列表中存在的所有值，然后检查是否所有值都已删除：

var allOfList1IsInList2 = !list1.Except(list2).Any();

此方法的优点是不需要两次调用 Count()。

Answer 3

C# 3.5+

使用Enumerable.All<TSource>判断List1中是否包含所有List2项：

bool hasAll = list2Uris.All(itm2 => list1Uris.Contains(itm2));

当 list1 包含的项目比 list2 的所有项目还要多时，这也有效。

Answer 4

Kent 的回答很好而且很简短，但他提供的解决方案总是需要对整个第一个集合进行迭代。以下是源代码：

public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
{
    if (first == null)
        throw Error.ArgumentNull("first");
    if (second == null)
        throw Error.ArgumentNull("second");
    return Enumerable.IntersectIterator<TSource>(first, second, comparer);
}

private static IEnumerable<TSource> IntersectIterator<TSource>(IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
{
    Set<TSource> set = new Set<TSource>(comparer);
    foreach (TSource source in second)
        set.Add(source);
    foreach (TSource source in first)
    {
        if (set.Remove(source))
            yield return source;
    }
}

这并不总是必需的。所以，这是我的解决方案：

public static bool Contains<T>(this IEnumerable<T> source, IEnumerable<T> subset, IEqualityComparer<T> comparer)
{
    var hashSet = new HashSet<T>(subset, comparer);
    if (hashSet.Count == 0)
    {
        return true;
    }

    foreach (var item in source)
    {
        hashSet.Remove(item);
        if (hashSet.Count == 0)
        {
            break;
        }
    }

    return hashSet.Count == 0;
}

其实你应该考虑使用ISet<T>（HashSet<T>）。它包含所有必需的设置方法。 IsSubsetOf 在你的情况下。

Answer 5

标记为答案的解决方案在重复的情况下会失败。如果您的 IEnumerable 仅包含不同的值，那么它将通过。

以下答案适用于 2 个重复的列表：

        int aCount = a.Distinct().Count();
        int bCount = b.Distinct().Count();

        return aCount == bCount &&
               a.Intersect(b).Count() == aCount;

Answer 6

你应该使用 HashSet 而不是 Array。

例子：

List1.SetEquals(List2); //returns true if the collections contains exactly same elements no matter the order they appear in the collection

Reference

唯一的 HasSet 限制是我们不能像 List 那样按索引获取项目，也不能像字典那样按 Key 获取项目。您所能做的就是枚举它们（对于每个，同时等）

Answer 7

Linq 运算符 SequenceEqual 也可以工作（但对可枚举项的顺序相同很敏感）

return list1Uris.SequenceEqual(list2Uris);

Answer 8

另一种方法是将您的超集列表转换为HashSet 并使用HashSet 的IsSuperSet 方法。

bool Contains(IEnumerable<Item> list1, IEnumerable<Item>, list2)
{
    var list1Values = list1.Select(item => item.Value);
    var list2Values = list2.Select(item => item.Value).ToHashSet();

    return list2Values.IsSupersetOf(list1Values);
}