Linq to Entities加入vs 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生成第一个列表中的条目列表,每个条目在第二个列表中包含一组已连接的条目.

这就是为什么在SQL中Join相当于INNER JOIN:没有条目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是匿名类型,其中包含一个type Parent属性和一个type属性IEnumerable<Child>.此查询语法使用GroupJoin引擎盖下的方法.

我们可以select g在后一个查询中执行,这将选择IEnumerable<IEnumerable<Child>>一个列表,例如列表.在许多情况下,包含父项的select更有用.

一些用例

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语句来转换为a .

这是查询(或综合)语法闪耀的地方.方法(或流利的)语法显示了真正发生的事情,但很难写:

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 joinLINQ中的单位是GroupJoin扁平的SelectMany.

2.保留订单

假设父母列表有点长.某些UI会按Id固定顺序生成所选父项列表作为值.我们来使用:

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

现在必须按照这个确切的顺序从父列表中过滤选定的父项.

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

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

...... parents将决定结果的顺序.如果父母被命令Id,结果将是父母2,3,4,7.不好.但是,我们也可以join用来过滤列表.通过使用ids第一个列表,订单将被保留:

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

结果是父母3,7,2,4.

Answer 2

根据eduLINQ:

掌握GroupJoin所做的最好方法是考虑加入.在那里,总的想法是我们查看"外部"输入序列,找到"内部"序列中的所有匹配项(基于每个序列上的键投影),然后产生成对的匹配元素.GroupJoin是类似的,除了不是产生元素对,它根据该项和匹配的"内部"项的序列为每个"外部"项产生单个结果.

唯一的区别在于回报声明:

加入:

var lookup = inner.ToLookup(innerKeySelector, comparer); 
foreach (var outerElement in outer) 
{ 
    var key = outerKeySelector(outerElement); 
    foreach (var innerElement in lookup[key]) 
    { 
        yield return resultSelector(outerElement, innerElement); 
    } 
} 

GroupJoin:

var lookup = inner.ToLookup(innerKeySelector, comparer); 
foreach (var outerElement in outer) 
{ 
    var key = outerKeySelector(outerElement); 
    yield return resultSelector(outerElement, lookup[key]); 
} 

在这里阅读更多:

• 重新实现LINQ to Objects:第19部分 - 加入

• 重新实现LINQ to Objects:Part 22 - GroupJoin