C# 在不同的通用列表之间进行选择的LINQ查询

我有两个通用列表，我想在其中运行两个Linq查询来找出：

列表A中是否有列表B中的项目

是否在列表B中找到所有列表A项目

以下是名单：

var ListA = new List<long>()
var ListB = new List<MyObject>()

我试图确定两件事（两个问题）：1。ListA中的任何长度是否与ListB中的任何MyObject.ItemId匹配？二,。可以在ListB中找到ListA中的所有long吗

ListA和ListB可以是不同的长度。对于第2项，我需要在ListB中找到ListA的所有项目，但反之亦然。我希望这是有道理的

谢谢

---

-Scott

首先，您只关心ListB中的ItemID，因此：

var bIDs = ListB.Select(x => x.ItemId);

为了回答你问题的第一部分，我将通过找到两个列表的交集（它们共享的所有项目的集合）来解决这个问题。如果其中至少有一个元素，则这两个元素之间存在重叠

var sharedIds = ListA.Intersect(bIDs);
if (sharedIds.Any())
    // list A contains at least one ItemID which ListB contains

至于第二部分，您希望查看列表A是否是列表B的子集。搜索此列表，堆栈溢出将显示：

此代码段之所以有效，是因为

ListA.Except（bIDs）

查找

ListA

具有

bIDs

不具有的元素。如果为空，则

ListA

不包含任何

bIDs

不包含的内容。因此，

ListA

中的所有内容也都在

bIDs

中

这里有一个例子：

A={1,2}

<代码>B={1,2,3}。A是B的子集。

A.Except（B）

为您提供了一个空集-B同时有1和2，因此不能在结果列表中，并且B中没有任何内容。因此，当A是B的子集时，

A.Except（B）。Any（）

为false，因为结果中没有元素；所以如果我们想处理这个案子，我们显然会否定它

为了完整性，如果我们交换A和B轮，使A不是B的子集：

A={1,2,3}

B={1,2}

，然后

A。除了（B）

给出

{3}

。它不能包含1或2，因为B包含1和2。但是B不包含3，所以

A。除了（B）

可以包含它。由于

{3}

包含一个元素，因此它不是空的，因此

A.Except（B）.Any（）

为真。否定，如果A不是B的子集，则为false

---

我的解释有点简洁；如果你想进一步查找（我建议你这样做——一点集合理论可以走很长的路），

a.Except（B）

是LINQ对集合差或相对集合补的名字。如果你愿意，Wikibooks有一个很好的设置理论。

首先，你只关心ListB中的ItemId，所以：

var bIDs = ListB.Select(x => x.ItemId);

为了回答你问题的第一部分，我将通过找到两个列表的交集（它们共享的所有项目的集合）来解决这个问题。如果其中至少有一个元素，则这两个元素之间存在重叠

var sharedIds = ListA.Intersect(bIDs);
if (sharedIds.Any())
    // list A contains at least one ItemID which ListB contains

至于第二部分，您希望查看列表A是否是列表B的子集。搜索此列表，堆栈溢出将显示：

此代码段之所以有效，是因为

ListA.Except（bIDs）

查找

ListA

具有

bIDs

不具有的元素。如果为空，则

ListA

不包含任何

bIDs

不包含的内容。因此，

ListA

中的所有内容也都在

bIDs

中

这里有一个例子：

A={1,2}

<代码>B={1,2,3}。A是B的子集。

A.Except（B）

为您提供了一个空集-B同时有1和2，因此不能在结果列表中，并且B中没有任何内容。因此，当A是B的子集时，

A.Except（B）。Any（）

为false，因为结果中没有元素；所以如果我们想处理这个案子，我们显然会否定它

为了完整性，如果我们交换A和B轮，使A不是B的子集：

A={1,2,3}

B={1,2}

，然后

A。除了（B）

给出

{3}

。它不能包含1或2，因为B包含1和2。但是B不包含3，所以

A。除了（B）

可以包含它。由于

{3}

包含一个元素，因此它不是空的，因此

A.Except（B）.Any（）

为真。否定，如果A不是B的子集，则为false

---

我的解释有点简洁；如果你想进一步查找（我建议你这样做——一点集合理论可以走很长的路），

a.Except（B）

是LINQ对集合差或相对集合补的名字。如果你愿意的话，Wikibooks有一个很好的设置理论。

假设你将

ItemIds

列表提取到

listB

，那么只需测试条件：

bool inListA = listA.Any(x => listB.Contains(x));

bool allInListB = listA.All(x => listB.Contains(x));

如果

ItemIds

bool inListA = listA.Any(x => listB.Select(b => b.ItemId).Contains(x));

bool allInListB = listA.All(x => listB.Select(b => b.ItemId).Contains(x));

---

为了测试条件，假设您将

ItemIds

列表提取到

listB

：

bool inListA = listA.Any(x => listB.Contains(x));

bool allInListB = listA.All(x => listB.Contains(x));

如果

ItemIds

bool inListA = listA.Any(x => listB.Select(b => b.ItemId).Contains(x));

bool allInListB = listA.All(x => listB.Select(b => b.ItemId).Contains(x));

---

如果您需要同时回答所有三个问题，那么纯LINQ解决方案可能不是最优的，因为每个查询都需要执行相同的交叉操作。进行一次交叉，然后使用该结果回答您的三个问题：

var tempSet = new HashSet<long>(ListA);
int uniqueAItemCount = tempSet.Count;

// 2b. "I would need all of ListA's items found in ListB, but not vice-versa."
tempSet.IntersectWith(ListB.Select(x => x.ItemId));
// tempSet now contains all items from ListA also found in ListB
// we can use this result to answer the other two questions...

// 1. "Do any of the longs in ListA match any of the MyObject.ItemId in ListB?"
bool anyAFoundInB = tempSet.Count > 0;

// 2a. "Can all of the longs in ListA be found in ListB?"
bool allAFoundInB = tempSet.Count == uniqueAItemCount;

var tempSet=newhashset（ListA）；
int uniqueAItemCount=tempSet.Count；
//2b。“我需要在ListB中找到ListA的所有项目，但反之亦然。”
IntersectWith（ListB.Select（x=>x.ItemId））；
//tempSet现在包含ListA中的所有项目，也可以在ListB中找到
//我们可以用这个结果来回答另外两个问题。。。
// 1. “ListA中的任何长度是否与ListB中的任何MyObject.ItemId匹配？”
bool anyafoundb=临时设置。计数>0；
//2a。“能否在ListB中找到ListA中的所有long？”
bool allafundinb=tempSet.Count==uniqueAItemCount；

如果您需要同时回答所有三个问题，那么纯LINQ解决方案可能不是最优的，因为每个查询都需要执行相同的交叉操作。做一次交叉，然后用r