使用LINQ加入[n]个集合并查找匹配项

使用LINQ，我可以在两个集合之间找到匹配的元素，如下所示：

        var alpha = new List<int>() { 1, 2, 3, 4, 5 };
        var beta = new List<int>() { 1, 3, 5 };

        return (from a in alpha
                join b in beta on a equals b
                select a);

var alpha=newlist（）{1,2,3,4,5}；
var beta=新列表（）{1,3,5}；
返回（从a到a）
在a等于b的β上加入b
选择a）；

我可以将其增加到三个系列，如下所示：

        var alpha = new List<int>() { 1, 2, 3, 4, 5 };
        var beta = new List<int>() { 1, 3, 5 };
        var gamma = new List<int>() { 3 };

        return (from a in alpha
                join b in beta on a equals b
                join g in gamma on a equals g
                select a);

var alpha=newlist（）{1,2,3,4,5}；
var beta=新列表（）{1,3,5}；
var gamma=新列表（）{3}；
返回（从a到a）
在a等于b的β上加入b
在gamma中加入g等于g
选择a）；

但是如何构造一个LINQ查询来返回N个集合之间的匹配？

---

我在想，如果每个集合都添加到父集合中，然后父集合使用递归循环进行迭代，它可能会起作用？

如果只有唯一的值可以使用Intersect：

var result = alpha.Intersect(beta).Intersect(gamma).ToList();

如果需要保留多个非唯一的值，可以将非相交项从原始集合中排除，作为附加步骤：

alpha = alpha.Where(x => result.Contains(x)).ToList();

要推广相交方法，您只需使用一个循环逐个进行所有相交：

IEnumerable<List<int>> collections = new [] { alpha, beta, gamma };
IEnumerable<int> result = collections.First();
foreach (var item in collections.Skip(1))
{
    result = result.Intersect(item);
}
result = result.ToList();

IEnumerable collections=new[]{alpha，beta，gamma}；
IEnumerable结果=collections.First（）；
foreach（集合中的变量项。跳过（1））
{
结果=结果.相交（项目）；
}
result=result.ToList（）；

如果只有唯一的值，则可以使用Intersect：

var result = alpha.Intersect(beta).Intersect(gamma).ToList();

如果需要保留多个非唯一的值，可以将非相交项从原始集合中排除，作为附加步骤：

alpha = alpha.Where(x => result.Contains(x)).ToList();

要推广相交方法，您只需使用一个循环逐个进行所有相交：

IEnumerable<List<int>> collections = new [] { alpha, beta, gamma };
IEnumerable<int> result = collections.First();
foreach (var item in collections.Skip(1))
{
    result = result.Intersect(item);
}
result = result.ToList();

IEnumerable collections=new[]{alpha，beta，gamma}；
IEnumerable结果=collections.First（）；
foreach（集合中的变量项。跳过（1））
{
结果=结果.相交（项目）；
}
result=result.ToList（）；

无需递归-只需迭代即可。但是，您可能会发现，最好创建一个集合，并每次相交：

List<List<int>> collections = ...;

HashSet<int> values = new HashSet<int>(collections[0]);
foreach (var collection in collections.Skip(1)) // Already done the first
{
    values.IntersectWith(collection);
}

List集合=。。。；
HashSet值=新的HashSet（集合[0]）；
foreach（collections.Skip（1））中的var collection//已完成第一步
{
与（集合）相交的值；
}

（像BrokenGlass一样，我假设您已经有了distint值，并且您真的只想找到所有集合中的值。）

如果您更喜欢不可变和懒惰的方法，您可以使用：

List<List<int>> collections = ...;

IEnumerable<int> values = collections[0];
foreach (var collection in collections.Skip(1)) // Already done the first
{
    values = values.Intersect(collection);
}

List集合=。。。；
IEnumerable值=集合[0]；
foreach（collections.Skip（1））中的var collection//已完成第一步
{
值=值。相交（集合）；
}

无需递归-只需迭代即可。但是，您可能会发现，最好创建一个集合，并每次相交：

List<List<int>> collections = ...;

HashSet<int> values = new HashSet<int>(collections[0]);
foreach (var collection in collections.Skip(1)) // Already done the first
{
    values.IntersectWith(collection);
}

List集合=。。。；
HashSet值=新的HashSet（集合[0]）；
foreach（collections.Skip（1））中的var collection//已完成第一步
{
与（集合）相交的值；
}

（像BrokenGlass一样，我假设您已经有了distint值，并且您真的只想找到所有集合中的值。）

如果您更喜欢不可变和懒惰的方法，您可以使用：

List<List<int>> collections = ...;

IEnumerable<int> values = collections[0];
foreach (var collection in collections.Skip(1)) // Already done the first
{
    values = values.Intersect(collection);
}

List集合=。。。；
IEnumerable值=集合[0]；
foreach（collections.Skip（1））中的var collection//已完成第一步
{
值=值。相交（集合）；
}