左外连接，这两种方法有什么区别？

Question

这两种使用 LINQ 执行左外连接的方法有什么区别，因为我都使用两个买家和供应商列表，并通过一个公共区域将它们连接起来以查找位于同一区域的供应商和买家。

class Supplier
{
    public string Name { get; set; }
    public string District { get; set; }
}

class Buyer
{
    public string Name { get; set; }
    public string District { get; set; }
}
List<Buyer> buyers = new List<Buyer>()
{
    new Buyer() { Name = "Johny", District = "Fantasy District" },
    new Buyer() { Name = "Peter", District = "Scientists District" },
    new Buyer() { Name = "Paul", District = "Fantasy District" },
    new Buyer() { Name = "Maria", District = "Scientists District" },
    new Buyer() { Name = "Joshua", District = "EarthIsFlat District" },
    new Buyer() { Name = "Sylvia", District = "Developers District" },
    new Buyer() { Name = "Rebecca", District = "Scientists District" },
    new Buyer() { Name = "Jaime", District = "Developers District" },
    new Buyer() { Name = "Pierce", District = "Fantasy District" }
};
List<Supplier> suppliers = new List<Supplier>()
{
    new Supplier() { Name = "Harrison", District = "Fantasy District" },
    new Supplier() { Name = "Charles", District = "Developers District" },
    new Supplier() { Name = "Hailee", District = "Scientists District" },
    new Supplier() { Name = "Taylor", District = "EarthIsFlat District" }
};

第一：

var suppliersAndBuyers = from s in suppliers
                         orderby s.District
                         join b in buyers on s.District equals b.District into buyersGroup
                         select buyersGroup.DefaultIfEmpty(
                             new Buyer()
                             {
                                 Name = string.Empty,
                                 District = s.District
                             });

foreach (var item in suppliersAndBuyers)
{
    foreach (var buyer in item)
    {
        Console.WriteLine($"{buyer.District} {buyer.Name}");
    }
}

第二种方法：

var suppliersAndBuyers = from s in suppliers
                                 orderby s.District
                                 join b in buyers on s.District equals b.District into buyersGroup
                                 from bG in buyersGroup.DefaultIfEmpty()
                                 select new
                                 {
                                     Name = bG.Name == null ? string.Empty : bG.Name,
                                     s.District,
                                 };

foreach (var item in suppliersAndBuyers)
{
    Console.WriteLine($"{item.District} {item.Name}");
}

两者都产生完全相同的输出，是我们输出结果方式的唯一区别吗？我应该使用哪一个？

编辑：第一种方法返回IEnumerable<IEnumerable<Buyer>>，第二种方法返回IEnumerable<AnonymousType>，这是两者在返回类型方面唯一有意义的区别，这是两者之间的唯一决定因素两种方法，我想要一个类型还是匿名类型？

Answer 1

好的。据我所见：(A)

var suppliersAndBuyers = from s in suppliers
                         orderby s.District

枚举供应商列表。这很明显。现在，将其加入买家列表：

var suppliersAndBuyers = from s in suppliers
                         orderby s.District
                         join b in buyers on s.District equals b.District

这会创建匹配项（一些我不知道类型的对象，因为我面前没有普通的 Visual Studio 实例）。但例如，它就像Harrison:Jonnie, Hailee:Peter, ...。现在我们可以根据这些匹配（由变量 b 和 s 表示）创建一个 IEnumerable 对象，如下所示：

var suppliersAndBuyers = from s in suppliers
                         orderby s.District
                         join b in buyers on s.District equals b.District
                         select new {
                             Supplier = s, Buyer = b
                         }

这将创建一个匿名类型的 IEnumerable，其中每个对象代表一对供应商和买方。

var suppliersAndBuyers = from s in suppliers
                         orderby s.District
                         join b in buyers on s.District equals b.District into buyersGroup

但是您决定做的是左连接，如您的标题中所写。它的作用是获取在 sn-p (A) 中创建的列表中的每个元素，并匹配买家列表中所有匹配对象的IEnumerable。这会产生可枚举的匹配项。例如，对于 Harrison，suppliers 列表中的第一个条目，您将获得一个 IEnumerable，其中包含 Johnny、Paul 和刺穿。 suppliers 列表中的其他元素也是如此，按其District 排序。

这就是您以IEnumerable<IEnumerable<Buyer>> 结尾的原因。因为对于每个供应商（第一个 IEnumerable 维度），您都有一个“列表”Buyer（第二个维度 + 类型解释）

然后合并空条目在我看来是过时的，因为你不应该有nulls，而只是空的IEnumerables，然后在遍历它们时，你不会碰到任何元素。 （虽然我不确定最后一段，因为我从来没有编译过代码所以我不知道）

---

现在关于合并部分，第一个示例为每个条目创建一个新的Buyer 对象，然后采用DefaultIsEmpty。对于第二个示例，它首先创建第一个维度和第二个维度 FULL IEnumerables，然后在再次迭代时，它会合并空值。正如我在 cmets 中提到的，其中一个不需要的循环。

Answer 2

在第一个中，由于new Buyer()，您返回了Buyer 中的IEnumerable，而在第二个中，由于select new，您返回了anonymous types 中的IEnumerable。它们各有优缺点。

您可以检查以下答案来决定：

https://stackoverflow.com/a/21443164/2946329

https://stackoverflow.com/a/48677/2946329

Answer 3

好的，所以我花了一些时间来破译这个:)

所以事情是在你正在做的第一个例子中

选择买家组.DefaultIfEmpty( 新买家（） { 名称 = 字符串。空， 区 = s.District });

该行的含义是...选择所有买家组，如果为空则返回new Buyer() { Name = string.Empty, District = s.District }（您将其定义为默认值）

第二个例子

来自buyersGroup.DefaultIfEmpty() 中的bG 选择新的 { 名称 = bG.Name == 空？ string.Empty : bG.Name, s.区， };

如果组为空，您首先定义默认值 BuyerGroup.DefaultIfEmpty()，然后才进行选择。密切注意 DefaultIfEmpty 括号括起来的内容。

编辑

我似乎根本找不到使用 DefaultIfEmpty 的理由...不要认为您可以在左侧获取 null 来需要它...而且它可能会使代码更容易理解。

Answer 4

见Enumerable.DefaultIfEmpty。在您的第一个示例中，如果在连接中找不到Buyer 实例（即您的外部连接），则将new Buyer 作为默认值传递给该扩展方法以在连接中返回。之后没有选择语句，因此连接的结果在您的结果中建模为IEnumerable<IEnumerable<Buyer>>。

您的第二个查询确实使用了带有匿名投影的select，这就是它导致集合扁平化的原因。

只看你得到的类型

• 您可以通过删除第二个查询中的select 来模仿第一个查询的结果

  from s in suppliers
  orderby s.District
  join b in buyers on s.District equals b.District into buyersGroup
  from bG in buyersGroup.DefaultIfEmpty();
  

• 如果想换个方向，您可以在第一个查询的末尾添加第二个查询中的相同选择语句。

  from s in suppliers
  orderby s.District
  join b in buyers on s.District equals b.District into buyersGroup
  select buyersGroup.DefaultIfEmpty(
      new Buyer()
      {
          Name = string.Empty,
          District = s.District
      ))
  select new
  {
      Name = bG.Name == null ? string.Empty : bG.Name,
      s.District,
  };
  

---

至于为什么使用一个而不是另一个，这是一个见仁见智的问题，也取决于情况。在没有任何其他上下文的非常简单的示例中，使用投影将是更易读的答案。如果您想将结果传递给另一个方法或从它正在执行的方法返回，那么IEnumerable<IEnumerable<Buyer>> 将是唯一的方法（如果受限于这两个样本）。如果您必须对数据存储执行此操作，那么我建议您对查询进行分析，以查看正在执行的查询是什么并对其进行分析。

简而言之，在您遇到特定的现实世界情况之前，没有正确/错误的答案，其中这两个与该度量之间存在可测量的差异，并且应用于它的权重取决于该情况。