c# - Linq-to-Entities Join vs GroupJoin

有人可以解释一下 GroupJoin() 是什么吗？
它与常规的 Join() 有何不同？
是否常用？
它仅用于方法语法吗？查询语法呢？ (一个 c# 代码示例会很好)

最佳答案

行为
假设您有两个列表:

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 相当于 SQL 中的 INNER JOIN :没有 C 的条目。虽然 GroupJoin 等价于 OUTER JOIN : C 在结果集中，但相关条目的列表为空(在 SQL 结果集中会有一行 0x2518131421)。
句法
所以让这两个列表分别为 C - null 和 IEnumerable<Parent>。 (如果是 Linq 到实体: IEnumerable<Child> )。
IQueryable<T> 语法是

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

返回一个 Join，其中 X 是一个匿名类型，具有两个属性， IEnumerable<X> 和 Value 。此查询语法在后台使用 ChildValue 方法。
Join 语法是

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

返回一个 GroupJoin，其中 Y 是一个匿名类型，由一个类型为 IEnumerable<Y> 的属性和一个类型为 Parent 的属性组成。此查询语法在后台使用 IEnumerable<Child> 方法。
我们可以在后一个查询中执行 GroupJoin ，这将选择一个 select g ，比如列表列表。在许多情况下，包含父项的选择更有用。
一些用例
1. 制作平面外连接。
如前所述，声明...

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

... 生成具有子组的 parent 列表。这可以通过两个小的添加变成父子对的平面列表:

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)

请注意，上述语句中重复使用了范围变量 IEnumerable<IEnumerable<Child>>。这样做后，任何 c 语句都可以通过将相当于 join 的等价物添加到现有的 outer join 语句来简单地转换为 into g from c in g.DefaultIfEmpty()。
这就是查询(或综合)语法的亮点。方法(或流利)语法显示了真正发生的事情，但很难编写:

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 } )

因此，LINQ 中的扁平 join 是 outer join ，被 GroupJoin 压平。
2. 保持秩序
假设 parent 名单有点长。某些 UI 以固定顺序生成选定父项的列表作为 SelectMany 值。让我们使用:

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

现在必须按照这个确切的顺序从父列表中过滤选定的父。
如果我们...

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

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

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

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

关于c# - Linq-to-Entities Join vs GroupJoin，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/15595289/