根据eduLINQ:

了解GroupJoin所做的事情的最好方法是考虑 加入。在这里，总体的想法是我们透过“外部” 输入序列，从“内”序列中找到所有匹配项 (基于每个序列上的关键投影)，然后产生对 匹配的元素。GroupJoin与此类似，不同之处在于 生成元素对，它为每个“外部”生成单个结果 项和匹配“内部”项的序列。

唯一的区别是return语句:

加入:

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:第19部分-连接 重新实现对象的LINQ:第22部分- GroupJoin

假设你有两个不同的类:

public class Person
{
    public string Name, Email;
    
    public Person(string name, string email)
    {
        Name = name;
        Email = email;
    }
}

class Data
{
    public string Mail, SlackId;
    
    public Data(string mail, string slackId)
    {
        Mail = mail;
        SlackId = slackId;
    }
}

现在，让我们准备数据来工作:

var people = new Person[]
    {
        new Person("Sudi", "sudi@try.cd"),
        new Person("Simba", "simba@try.cd"),
        new Person("Sarah", string.Empty)
    };
    
    var records = new Data[]
    {
        new Data("sudi@try.cd", "Sudi_Try"),
        new Data("sudi@try.cd", "Sudi@Test"),
        new Data("simba@try.cd", "SimbaLion")
    };

你会注意到sudi@try.cd有两个slackid。我做这个是为了演示如何 加入工作。

现在让我们构造查询来连接Person和Data:

var query = people.Join(records,
        x => x.Email,
        y => y.Mail,
        (person, record) => new { Name = person.Name, SlackId = record.SlackId});
    Console.WriteLine(query);

在构造查询之后，你还可以像这样用foreach遍历它:

foreach (var item in query)
    {
        Console.WriteLine($"{item.Name} has Slack ID {item.SlackId}");
    }

让我们也输出GroupJoin的结果:

Console.WriteLine(
    
        people.GroupJoin(
            records,
            x => x.Email,
            y => y.Mail,
            (person, recs) => new {
                Name = person.Name,
                SlackIds = recs.Select(r => r.SlackId).ToArray() // You could materialize //whatever way you want.
            }
        ));

您将注意到GroupJoin将所有slackid放在一个组中。

行为

假设你有两个列表:

Id  Value
1   A
2   B
3   C

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

当你加入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结果集中会有一行C - null)。

语法

因此，设两个列表分别为IEnumerable<Parent>和IEnumerable<Child>。(如果Linq to Entities: IQueryable<T>)。

联接语法将是

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方法。

我们可以在后面的查询中选择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在上面的语句中被重用了。这样，任何连接语句都可以简单地转换为外部连接，方法是将g. defaultifempty()中的into g from c的等价值添加到现有的连接语句中。

这就是查询(或综合)语法的亮点所在。方法(或流畅)语法显示了实际发生的情况，但很难编写:

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中的扁平外部连接是一个GroupJoin，由SelectMany扁平。

2. 保存订单

假设父母的列表稍微长一点。一些UI以固定的顺序生成一个被选中的父元素的Id值列表。让我们使用:

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

现在，所选的父元素必须按照这个顺序从父元素列表中过滤出来。

如果我们……

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

．.． 父母的顺序将决定结果。如果父节点按Id排序，结果将是父节点2,3,4,7。不好的。但是，我们也可以使用join来筛选列表。通过使用id作为第一个列表，顺序将保持不变:

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

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

根据eduLINQ:

了解GroupJoin所做的事情的最好方法是考虑 加入。在这里，总体的想法是我们透过“外部” 输入序列，从“内”序列中找到所有匹配项 (基于每个序列上的关键投影)，然后产生对 匹配的元素。GroupJoin与此类似，不同之处在于 生成元素对，它为每个“外部”生成单个结果 项和匹配“内部”项的序列。

唯一的区别是return语句:

加入:

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:第19部分-连接 重新实现对象的LINQ:第22部分- GroupJoin