C# 从嵌套列表中获取项

我有一个包含2个其他列表的类的列表（实际上是HashSet）。下面是一个包含示例数据的模型：

public class Example
{
    public Example(HashSet<int> a, HashSet<int> b)
    {
        ListA = a;
        ListB = b;
    }

    public HashSet<int> ListA { get; set; }
    public HashSet<int> ListB { get; set; }
}

public class UseCase
{
    public UseCase()
    {
        var hs = new HashSet<Example>();
        hs.Add(new Example(new HashSet<int> { 1}, new HashSet<int> { 100, 200 }));
        hs.Add(new Example(new HashSet<int> { 2,3,4,5 }, new HashSet<int> { 100, 200, 300 }));
        hs.Add(new Example(new HashSet<int> { 6,9,12 }, new HashSet<int> { 200, 300 }));
    }
}

公共类示例
{
公共示例（哈希集a、哈希集b）
{
ListA=a；
ListB=b；
}
公共HashSet ListA{get；set；}
公共HashSet ListB{get；set；}
}
公共类用例
{
公共用例（）
{
var hs=新的HashSet（）；
Add（新示例（新HashSet{1}，新HashSet{100200}））；
Add（新示例（新哈希集{2,3,4,5}，新哈希集{100200300}））；
Add（新示例（新HashSet{6,9,12}，新HashSet{200300}））；
}
}

以下是两个列表的规则：

列表A只包含唯一的数字-它们在自己的哈希集或任何其他列表A哈希集中都不会重复

列表B包含在其自己的哈希集中唯一的数字，但它们可以在一个或多个列表B哈希集中重复

我要做的是返回匹配ListA行中的所有数字，其中ListB中存在一个特定的数字

下面是一个模拟linq查询：

public static IEnumerable<int> GetDistinctFromListA(int b)
{
    return UsesCases
        .Where(x => x.ListB.Contains(b))
}

公共静态IEnumerable GetDistinctFromListA（int b）
{
返回使用情况
其中（x=>x.ListB.Contains（b））
}

所以，在这一点上，我有很多行，但我现在需要从匹配的ListB列表中提取所有数字。如果输入的参数是100，那么我希望返回一个包含数字1、2、3、4和5的列表

---

我一直在玩All和SelectMany的游戏，但似乎无法得到我需要的结果。

我想你应该返回两组的交集

有一个Linq函数可以做到这一点

var commonInBoth = List1.Intersect(List2);

---

我想你应该返回两组的交集

有一个Linq函数可以做到这一点

var commonInBoth = List1.Intersect(List2);

---

HashSet

意味着只包含唯一的值，也就是说，您进行的所有查询本质上都返回不同的值。如果要查找两个

HashSet

之间的交集，可以调用

Intersect

方法

例如：

//The additional 1 is ignored here
HashSet<int> A = new HashSet<int> { 1, 1, 2, 3, 4, 5 };
HashSet<int> B = new HashSet<int> { 1, 5, 8, 9 };
var Result = A.Intersect(B);

//此处忽略附加的1
HashSet A=新的HashSet{1,1,2,3,4,5}；
HashSet B=新的HashSet{1,5,8,9}；
var结果=A.相交（B）；

A

HashSet

意味着只包含唯一的值，也就是说，您进行的所有查询都固有地返回不同的值。如果要查找两个

HashSet

之间的交集，可以调用

Intersect

方法

例如：

//The additional 1 is ignored here
HashSet<int> A = new HashSet<int> { 1, 1, 2, 3, 4, 5 };
HashSet<int> B = new HashSet<int> { 1, 5, 8, 9 };
var Result = A.Intersect(B);

//此处忽略附加的1
HashSet A=新的HashSet{1,1,2,3,4,5}；
HashSet B=新的HashSet{1,5,8,9}；
var结果=A.相交（B）；

公共类示例
{
公共示例（哈希集a、哈希集b）
{
ListA=a；
ListB=b；
}
公共HashSet ListA{get；set；}
公共HashSet ListB{get；set；}
}
静态IEnumerable GetDistinctFromListA（哈希集hs，int b）
{
var rv=hs.Aggregate（新HashSet（），（acc，el）=>
{
如果（el.ListB.包含（b））与（el.ListA）一致；
返回acc；
});
返回rv；
}
静态void Main（字符串[]参数）
{
var hs=新的HashSet（）；
Add（新示例（新HashSet{1}，新HashSet{100200}））；
Add（新示例（新哈希集{2,3,4,5}，新哈希集{100200300}））；
Add（新示例（新HashSet{6,9,12}，新HashSet{200,300}））；
foreach（hs.SelectMany（e=>e.ListB.Distinct（）中的变量b）
Console.WriteLine（$“{b}=>{string.Join（“，”，GetDistinctFromListA（hs，b））}）；
Console.ReadLine（）；
}

这将遍历hs的所有元素，检查每个元素ListB是否包含b，如果包含b，则将其ListA元素添加到结果中

如果只比较hashset而不依赖其他hashset，则可以使用Intersect/Union/Except等（集合论的东西）。

公共类示例
{
公共示例（哈希集a、哈希集b）
{
ListA=a；
ListB=b；
}
公共HashSet ListA{get；set；}
公共HashSet ListB{get；set；}
}
静态IEnumerable GetDistinctFromListA（哈希集hs，int b）
{
var rv=hs.Aggregate（新HashSet（），（acc，el）=>
{
如果（el.ListB.包含（b））与（el.ListA）一致；
返回acc；
});
返回rv；
}
静态void Main（字符串[]参数）
{
var hs=新的HashSet（）；
Add（新示例（新HashSet{1}，新HashSet{100200}））；
Add（新示例（新哈希集{2,3,4,5}，新哈希集{100200300}））；
Add（新示例（新HashSet{6,9,12}，新HashSet{200,300}））；
foreach（hs.SelectMany（e=>e.ListB.Distinct（）中的变量b）
Console.WriteLine（$“{b}=>{string.Join（“，”，GetDistinctFromListA（hs，b））}）；
Console.ReadLine（）；
}

这将遍历hs的所有元素，检查每个元素ListB是否包含b，如果包含b，则将其ListA元素添加到结果中

---

如果只比较hashset而不依赖其他hashset，则可以使用Intersect/Union/Except等（集合论的东西）。

什么是用例？

hs.Where（x=>x.ListB.Contains（100））。SelectMany（x=>x.ListA）

适合我？-->

SelectManyIterator{1,2,3,4,5}

@Patrick-它只是表示我创建的集合-它是一个静态哈希集，与UseCase类中的哈希集相同您真的不应该调用哈希集“列表”。它们不是列表，而是哈希集。什么是用例？

hs.Where（x=>x.ListB.Contains（100））。选择many（x=>x.ListA）

对我有效？-->

SelectManyIterator{1,2,3,4,5}

@Patrick-它只是表示我创建的集合-它是一个静态哈希集，与UseCase类中的哈希集相同您真的不应该调用哈希集“列表”。它们不是列表，而是散列集。我认为这是正确的方法。另外，我认为你错过了一个结束语（代码）还有一件事。显然，

HashSet

没有

AddRange

，但它有

UnionWi