219

有人可以解释一下 aGroupJoin()是什么吗？

和普通的有什么区别Join()？

是常用的吗？

它仅适用于方法语法吗？查询语法呢？（一个 c# 代码示例会很好）

4

3 回答 3

429

行为

假设您有两个列表：

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在第一个列表中生成一个条目列表，每个条目在第二个列表中都有一组连接的条目。

这就是为什么在 SQLJoin中是等价的INNER JOIN：没有C. WhileGroupJoin相当于OUTER JOIN: Cis 在结果集中，但相关条目的列表为空（在 SQL 结果集中会有一行C - null）。

句法

所以让这两个列表分别为IEnumerable<Parent>和IEnumerable<Child>。（在 Linq to Entity 的情况下：）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来简单地转换为 an 。outer joininto 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 中的 flat是GroupJoin, 由SelectMany.

2. 维护秩序

假设父母的名单有点长。Id某些 UI以固定顺序生成选定父项的列表作为值。让我们使用：

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。

于 2013-03-24T13:40:25.783 回答
21

根据eduLINQ：

掌握 GroupJoin 功能的最佳方法是考虑 Join。在那里，总体思路是我们查看“外部”输入序列，从“内部”序列中找到所有匹配项（基于每个序列上的键投影），然后产生匹配元素对。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); 
    } 
}

群组加入：

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

在这里阅读更多：

于 2013-03-24T10:06:00.410 回答
1

假设您有两个不同的类：

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。我这样做是为了演示 Join 的工作原理。

现在让我们构造查询以将 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 放在一个组中。

于 2020-11-13T02:06:20.460 回答