C# 与任意数量的列表相交

假设我有任意数量的列表

List<int> List1 = new List<int>();
List<int> List2 = new List<int>();
List<int> ListN = new List<int>();

List List1=新列表（）；
List List2=新列表（）；
List ListN=新列表（）；

我如何才能得到一个只包含每个列表中存在的元素的最终列表

我最初是通过许多循环来实现的。但我并不满意。由于我对LINQ的了解有限，我认为这应该很容易做到，但我甚至不知道从哪里开始

---

有没有其他方法可以做到这一点，最好是使用LINQ。

使用

Intersect

var r = List1.Intersect(List2).Intersect(ListN);

例如：

var r = new [] { 1, 2, 3, 4 }
    .Intersect(new [] { 2, 3, 4, 5 })
    .Intersect(new [] { 3, 4, 5, 6 });
// r now contains 3, 4

文件：

下面是一个扩展方法，它获取列表列表并对所有列表执行交集。同上，但使用起来可能更简单

public static IEnumerable<T> IntersectAll<T>(
   this IEnumerable<T> list, 
   params IEnumerable<T>[] otherLists
) {
    foreach (var otherList in otherLists)
    {
        list = list.Intersect(otherList);
    }
    return list;
}

---

使用

Intersect

var r = List1.Intersect(List2).Intersect(ListN);

例如：

var r = new [] { 1, 2, 3, 4 }
    .Intersect(new [] { 2, 3, 4, 5 })
    .Intersect(new [] { 3, 4, 5, 6 });
// r now contains 3, 4

文件：

下面是一个扩展方法，它获取列表列表并对所有列表执行交集。同上，但使用起来可能更简单

public static IEnumerable<T> IntersectAll<T>(
   this IEnumerable<T> list, 
   params IEnumerable<T>[] otherLists
) {
    foreach (var otherList in otherLists)
    {
        list = list.Intersect(otherList);
    }
    return list;
}

---

使用

Intersect

var r = List1.Intersect(List2).Intersect(ListN);

例如：

var r = new [] { 1, 2, 3, 4 }
    .Intersect(new [] { 2, 3, 4, 5 })
    .Intersect(new [] { 3, 4, 5, 6 });
// r now contains 3, 4

文件：

下面是一个扩展方法，它获取列表列表并对所有列表执行交集。同上，但使用起来可能更简单

public static IEnumerable<T> IntersectAll<T>(
   this IEnumerable<T> list, 
   params IEnumerable<T>[] otherLists
) {
    foreach (var otherList in otherLists)
    {
        list = list.Intersect(otherList);
    }
    return list;
}

---

使用

Intersect

var r = List1.Intersect(List2).Intersect(ListN);

例如：

var r = new [] { 1, 2, 3, 4 }
    .Intersect(new [] { 2, 3, 4, 5 })
    .Intersect(new [] { 3, 4, 5, 6 });
// r now contains 3, 4

文件：

下面是一个扩展方法，它获取列表列表并对所有列表执行交集。同上，但使用起来可能更简单

public static IEnumerable<T> IntersectAll<T>(
   this IEnumerable<T> list, 
   params IEnumerable<T>[] otherLists
) {
    foreach (var otherList in otherLists)
    {
        list = list.Intersect(otherList);
    }
    return list;
}

列表列表=新列表{
列表2，…，列表n
};
IEnumerable结果=列表1；
foreach（列表中的变量列表）{
结果=结果.相交（列表）；
如果（！result.Any（））中断；
}
//对结果使用ToList（）获取列表

列表列表=新列表{
列表2，…，列表n
};
IEnumerable结果=列表1；
foreach（列表中的变量列表）{
结果=结果.相交（列表）；
如果（！result.Any（））中断；
}
//对结果使用ToList（）获取列表

列表列表=新列表{
列表2，…，列表n
};
IEnumerable结果=列表1；
foreach（列表中的变量列表）{
结果=结果.相交（列表）；
如果（！result.Any（））中断；
}
//对结果使用ToList（）获取列表

列表列表=新列表{
列表2，…，列表n
};
IEnumerable结果=列表1；
foreach（列表中的变量列表）{
结果=结果.相交（列表）；
如果（！result.Any（））中断；
}
//对结果使用ToList（）获取列表

非常简单：

var intersection = List1.Intersect(List2).Intersect(List3);

或者，如果您希望轻松支持n个列表：

var lists = new List<List<string>>();

lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test3" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test4" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test5" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test6" }));

var aggregate = lists.Aggregate((x, y) => x.Intersect(y).ToList());

var List=newlist（）；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test3”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test4”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test5”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test6”}））；
var aggregate=lists.aggregate（（x，y）=>x.Intersect（y.ToList（））；

非常简单：

var intersection = List1.Intersect(List2).Intersect(List3);

或者，如果您希望轻松支持n个列表：

var lists = new List<List<string>>();

lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test3" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test4" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test5" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test6" }));

var aggregate = lists.Aggregate((x, y) => x.Intersect(y).ToList());

var List=newlist（）；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test3”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test4”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test5”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test6”}））；
var aggregate=lists.aggregate（（x，y）=>x.Intersect（y.ToList（））；

非常简单：

var intersection = List1.Intersect(List2).Intersect(List3);

或者，如果您希望轻松支持n个列表：

var lists = new List<List<string>>();

lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test3" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test4" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test5" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test6" }));

var aggregate = lists.Aggregate((x, y) => x.Intersect(y).ToList());

var List=newlist（）；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test3”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test4”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test5”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test6”}））；
var aggregate=lists.aggregate（（x，y）=>x.Intersect（y.ToList（））；

非常简单：

var intersection = List1.Intersect(List2).Intersect(List3);

或者，如果您希望轻松支持n个列表：

var lists = new List<List<string>>();

lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test3" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test4" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test5" }));
lists.Add(new List<string>(new string[] { "Test1", "Test2", "Test6" }));

var aggregate = lists.Aggregate((x, y) => x.Intersect(y).ToList());

var List=newlist（）；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test3”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test4”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test5”}））；
Add（新列表（新字符串[]{“Test1”、“Test2”、“Test6”}））；
var aggregate=lists.aggregate（（x，y）=>x.Intersect（y.ToList（））；

虽然您可以使用LINQ的

Intersect

方法，但这将导致不断获取当前的交叉点，并用这些项重新填充新的

哈希集。通过使用自己的显式
HashSet
可以更有效地获得N个序列的交集：

public static IEnumerable<T> intersectAll<T>(IEnumerable<IEnumerable<T>> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            return Enumerable.Empty<T>();

        var set = new HashSet<T>(iterator.Current);
        while (iterator.MoveNext())
            set.IntersectWith(iterator.Current);

        return set;
    }
}

公共静态IEnumerable intersectAll（IEnumerable源）
{
使用（var iterator=source.GetEnumerator（））
{
如果（！iterator.MoveNext（））
返回可枚举的.Empty（）；
var set=新的HashSet（iterator.Current）；
while（iterator.MoveNext（））
set.IntersectWith（iterator.Current）；
返回集；
}
}
虽然您可以使用LINQ的
Intersect
方法，但这将导致不断获取当前的交叉点，并用这些项重新填充新的
哈希集。通过使用自己的显式
HashSet
可以更有效地获得N个序列的交集：

public static IEnumerable<T> intersectAll<T>(IEnumerable<IEnumerable<T>> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            return Enumerable.Empty<T>();

        var set = new HashSet<T>(iterator.Current);
        while (iterator.MoveNext())
            set.IntersectWith(iterator.Current);

        return set;
    }
}

公共静态IEnumerable intersectAll（IEnumerable源）
{
使用（var iterator=source.GetEnumerator（））
{
如果（！iterator.MoveNext（））
返回可枚举的.Empty（）；
var set=新的HashSet（iterator.Current）；
while（iterator.MoveNext（））
set.IntersectWith（iterator.Current）；
返回集；
}
}
虽然您可以使用LINQ的
Intersect
方法，但这将导致不断获取当前的交叉点，并用这些项重新填充新的
哈希集。通过使用自己的显式
HashSet
可以更有效地获得N个序列的交集：

public static IEnumerable<T> intersectAll<T>(IEnumerable<IEnumerable<T>> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
            return Enumerable.Empty<T>();

        var set = new HashSet<T>(iterator.Current);
        while (iterator.MoveNext())
            set.IntersectWith(iterator.Current);

        return set;
    }
}

公共静态IEnumerable intersectAll（IEnumerable源）
{
使用（var iterator=source.GetEnumerator（））
{