c# - Linq-to-Entities 加入与 GroupJoin

Question

谁能解释一下 GroupJoin() 是什么？

它与常规 Join() 有何不同？

常用吗？

它只针对方法语法吗？查询语法呢？ (一个 c# 代码示例会很好)

Answer 1

行为

假设您有两个列表:

Id  Value
1   A
2   B
3   C

Id  ChildValue
1   a1
1   a2
1   a3
2   b1
2   b2

当你 Join Id 上的两个列表结果将是:

Value ChildValue
A     a1
A     a2
A     a3
B     b1
B     b2

当你 GroupJoin Id 上的两个列表结果将是:

Value  ChildValues
A      [a1, a2, a3]
B      [b1, b2]
C      []

所以 Join生成父值和子值的平面(表格)结果。
GroupJoin在第一个列表中生成一个条目列表，每个条目在第二个列表中都有一组连接的条目。

这就是为什么 Join相当于INNER JOIN在 SQL 中:没有 C 的条目.同时 GroupJoin相当于OUTER JOIN : C在结果集中，但相关条目列表为空(在 SQL 结果集中会有一行 C - null)。

语法

所以让两个列表为IEnumerable<Parent>和 IEnumerable<Child>分别。 (如果是 Linq to Entities:IQueryable<T>)。

Join 语法为

from p in Parent
join c in Child on p.Id equals c.Id
select new { p.Value, c.ChildValue }

返回 IEnumerable<X>其中 X 是具有两个属性的匿名类型，Value和 ChildValue .此查询语法使用 Join 引擎盖下的方法。

GroupJoin 语法为

from p in Parent
join c in Child on p.Id equals c.Id into g
select new { Parent = p, Children = g }

返回 IEnumerable<Y>其中 Y 是一个匿名类型，由一个 Parent 类型的属性组成和 IEnumerable<Child> 类型的属性.此查询语法使用 GroupJoin 引擎盖下的方法。

我们可以做 select g在后一个查询中，它将选择 IEnumerable<IEnumerable<Child>> ，说一个列表列表。在许多情况下，包含父项的选择更有用。

一些用例

1。生成平面外部联接。

如前所述，声明...

from p in Parent
join c in Child on p.Id equals c.Id into g
select new { Parent = p, Children = g }

... 生成带有子组的父列表。这可以通过两个小的添加变成一个简单的父子对列表:

from p in parents
join c in children on p.Id equals c.Id into g // <= into
from c in g.DefaultIfEmpty()               // <= flattens the groups
select new { Parent = p.Value, Child = c?.ChildValue }

结果类似于

Value Child
A     a1
A     a2
A     a3
B     b1
B     b2
C     (null)

注意范围变量 c在上面的语句中被重用。这样做，任何 join语句可以简单地转换为 outer join通过添加相当于 into g from c in g.DefaultIfEmpty()到现有的 join声明。

这是查询(或综合)语法的亮点所在。方法(或流利)语法显示了真正发生的事情，但很难写:

parents.GroupJoin(children, p => p.Id, c => c.Id, (p, c) => new { p, c })
       .SelectMany(x => x.c.DefaultIfEmpty(), (x,c) => new { x.p.Value, c?.ChildValue } )

太平了outer join在 LINQ 中是 GroupJoin , 被 SelectMany 压平.

2。保留顺序

假设 parent 名单有点长。某些 UI 会生成一个选定的 parent 列表，格式为 Id。固定顺序的值。让我们使用:

var ids = new[] { 3,7,2,4 };

现在必须按此确切顺序从 parent 列表中过滤出选定的 parent 。

如果我们这样做......

var result = parents.Where(p => ids.Contains(p.Id));

... parents 的顺序将决定结果。如果 parent 是按Id点的，结果将是 parent 2、3、4、7。不好。但是，我们也可以使用 join过滤列表。并通过使用 ids作为第一个列表，顺序将被保留:

from id in ids
join p in parents on id equals p.Id
select p

结果是 parent 3, 7, 2, 4。