LINQ联接序列的五种简单方法

今天我们来看看5种使用Linq函数联接序列的方法，这5种方法可以归入下列两类：

同类的联接

Concat()

Union()

不同类的联接

Zip()

Join()

GroupJoin()

Concat() – 串联序列

最简单的序列合并，concat仅仅是将第二个序列接在***个序列后面， 注意：返回的序列并没有改变原来元素的顺序：

 
 
 
    
  
  
  
  1.  var healthFoods = new List { "fruits", "vegetables", "grains", "proteins" }; 
    2. 
  
  
  
  2. var myFoods = new List { "grains", "proteins", "M&Ms", "soda" }; 
    3. 
  
  
  
  3. // 返回序列: fruits, vegetables, grains, proteins, grains, proteins, M&Ms, soda 
    4. 
  
  
  
  4. var healthyFirst = healthFoods.Concat(myFoods); 
    5. 
  
  
  
  5. // 返回序列: grains, proteins, M&Ms, soda, fruits, vegetables, grains, proteins 
    6. 
  
  
  
  6. var mineFirst = myFoods.Concat(healthFoods);
    7.

Union() – 无重复项的串联序列

该方法用于结合两个没有重复项的集合，也非常适用于任何两个序列。 它将第二个序列结合到***个序列里，当第二个序列中出现与***个序列重复的项时，它只保留***序列的项目。

是否是重复的项目取决于IEqualityComparer ，如果你没有提供个性化的定义，则使用该类型的默认函数。 请注意，如果 T 是一个自定义的类型，这意味着你同时需要一个有效的Equals（） 和 GetHashCode（）的定义。

 
 
 
    
  
  
  
  1. // 返回序列: fruits, vegetables, grains, proteins, M&Ms, soda 
    2. 
  
  
  
  2. var healthyFirst = healthFoods.Union(myFoods); 
    3. 
  
  
  
  3. // 返回序列: grains, proteins, M&Ms, soda, fruits, vegetables 
    4. 
  
  
  
  4. var mineFirst = myFoods.Union(healthFoods);
    5.

Zip() – 简单一对一的联接

该方法针对两个不同类执行一个最简单的联接。 比如给定两个序列，它仅仅将他们的***个项合并，而后将他们第二个项合并,…，一旦到达较短序列的***一项，它就会立即停止。

比方说，比如，我们有下面的类定义：

 
 
 
    
  
  
  
  1.  public class Employee 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     public int Id { get; set; } 
    4. 
  
  
  
  4.     public string Name { get; set; } 
    5. 
  
  
  
  5.     public double Salary { get; set; } 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. public class Seat 
    8. 
  
  
  
  8. { 
    9. 
  
  
  
  9.     public int Id { get; set; } 
    10. 
  
  
  
  10.     public double Cost { get; set; } 
    11. 
  
  
  
  11. }
    12.

然后，我们确定了以下顺序：

 
 
 
    
  
  
  
  1.  var employees = new List 
    2. 
  
  
  
  2.     { 
    3. 
  
  
  
  3.         new Employee { Id = 13, Name = "John Doe", Salary = 13482.50 }, 
    4. 
  
  
  
  4.         new Employee { Id = 42, Name = "Sue Smith", Salary = 98234.13 }, 
    5. 
  
  
  
  5.         new Employee { Id = 99, Name = "Jane Doe", Salary = 32421.12 } 
    6. 
  
  
  
  6.     }; 
    7. 
  
  
  
  7. var seats = new List 
    8. 
  
  
  
  8.     { 
    9. 
  
  
  
  9.         new Seat { Id = 1, Cost = 42 }, 
    10. 
  
  
  
  10.         new Seat { Id = 2, Cost = 42 }, 
    11. 
  
  
  
  11.         new Seat { Id = 3, Cost = 100 }, 
    12. 
  
  
  
  12.         new Seat { Id = 4, Cost = 100 }, 
    13. 
  
  
  
  13.         new Seat { Id = 5, Cost = 125 }, 
    14. 
  
  
  
  14.         new Seat { Id = 6, Cost = 125 }, 
    15. 
  
  
  
  15.     };
    16.

我们可以联接它们，给每个雇员提供一个座位：

 
 
 
    
  
  
  
  1. var seatingAssignments = employees.Zip(seats, (e, s) => new
    2. 
  
  
  
  2.     { EmployeeId = e.Id, SeatId = s.Id }); 
    3. 
  
  
  
  3. foreach (var seat in seatingAssignments) 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5.     Console.WriteLine("雇员: " + seat.EmployeeId + " 预约了座位 " + seat.SeatId); 
    6. 
  
  
  
  6. 
  
  
  
  7. }     
    8.

我们可以得到：

雇员: 13 预约了座位1

雇员: 42 预约了座位2

雇员: 99 预约了座位3

Join() – 满足条件的联接

“使用 join 子句可以将来自不同源序列并且在对象模型中没有直接关系的元素相关联。 唯一的要求是每个源中的元素需要共享某个可以进行比较以判断是否相等的值。 例如，食品经销商可能具有某种产品的供应商列表以及买主列表。 例如，可以使用 join 子句创建该产品同一指定地区供应商和买主的列表。

join 子句接受两个源序列作为输入。 每个序列中的元素都必须是可以与另一个序列中的相应属性进行比较的属性，或者包含一个这样的属性。 join 子句使用特殊的 equals 关键字比较指定的键是否相等。 join 子句执行的所有联接都是同等联接。 join 子句的输出形式取决于所执行的联接的具体类型。 ”

是否相等取决于IEqualityComparer，如果你使用自定义的类型，你需要提供 Equals() 和 GetHashCode() 或者提供一个自定义的 IEqualityComparer. 但是你使用的.NET 中的类型，则一般不需要再另外实现这些函数。

上例子，使用之前的Employee类，再加一个Badge类，然后我们再创建这一组序列：

 
 
 
    
  
  
  
  1.  public class Badge 
    2. 
  
  
  
  2. { 
    3. 
  
  
  
  3.     public int EmployeeId { get; set; } 
    4. 
  
  
  
  4.     public int BadgeNumber { get; set; } 
    5. 
  
  
  
  5. } 
    6. 
  
  
  
  6. var employees = new List 
    7. 
  
  
  
  7.     { 
    8. 
  
  
  
  8.         new Employee { Id = 13, Name = "John Doe", Salary = 13482.50 }, 
    9. 
  
  
  
  9.         new Employee { Id = 42, Name = "Sue Smith", Salary = 98234.13 }, 
    10. 
  
  
  
  10.         new Employee { Id = 99, Name = "Jane Doe", Salary = 32421.12 } 
    11. 
  
  
  
  11.     }; 
    12. 
  
  
  
  12. var badges = new List 
    13. 
  
  
  
  13.     { 
    14. 
  
  
  
  14.         new Badge { EmployeeId = 10, BadgeNumber = 1 }, 
    15. 
  
  
  
  15.         new Badge { EmployeeId = 13, BadgeNumber = 2 }, 
    16. 
  
  
  
  16.         new Badge { EmployeeId = 20, BadgeNumber = 3 }, 
    17. 
  
  
  
  17.         new Badge { EmployeeId = 25, BadgeNumber = 4 }, 
    18. 
  
  
  
  18.         new Badge { EmployeeId = 42, BadgeNumber = 5 }, 
    19. 
  
  
  
  19.         new Badge { EmployeeId = 10, BadgeNumber = 6 }, 
    20. 
  
  
  
  20.         new Badge { EmployeeId = 13, BadgeNumber = 7 }, 
    21. 
  
  
  
  21.     };
    22.

这样我们就可以使用Join 来对它们进行操作了：

 
 
 
    
  
  
  
  1.  var badgeAssignments = employees.Join(badges, e => e.Id, b => b.EmployeeId, 
    2. 
  
  
  
  2.     (e, b) => new { e.Name, b.BadgeNumber }); 
    3. 
  
  
  
  3. foreach (var badge in badgeAssignments) 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5.     Console.WriteLine("Name: " + badge.Name + " has badge " + badge.BadgeNumber); 
    6. 
  
  
  
  6. }   
    7.

返回的结果是：

  Name: John Doe has badge 2

 Name: John Doe has badge 7

 Name: Sue Smith has badge 5

Join 对于1:1的关系是非常实用的，或者如果你不在乎返回一些重复的1:N的关系，你也可以是用Join.

GroupJoin() – 适用于一对多的条件联接

那么，如果你有1：N的关系，你希望这些结果分类组合在一起就可以用到 GroupJoin（），仍旧用上面的例子：

 
 
 
    
  
  
  
  1.  var badgeAssignments = employees.GroupJoin(badges, e => e.Id, b => b.EmployeeId, 
    2. 
  
  
  
  2.     (e, bList) => new { Name = e.Name, Badges = bList.ToList() }); 
    3. 
  
  
  
  3. foreach (var assignment in badgeAssignments) 
    4. 
  
  
  
  4. { 
    5. 
  
  
  
  5.     Console.WriteLine(assignment.Name + " has badges:"); 
    6. 
  
  
  
  6.     if (assignment.Badges.Count > 0) 
    7. 
  
  
  
  7.     { 
    8. 
  
  
  
  8.         foreach (var badge in assignment.Badges) 
    9. 
  
  
  
  9.         { 
    10. 
  
  
  
  10.             Console.WriteLine("\tBadge: " + badge.BadgeNumber); 
    11. 
  
  
  
  11.         } 
    12. 
  
  
  
  12.     } 
    13. 
  
  
  
  13.     else
    14. 
  
  
  
  14.     { 
    15. 
  
  
  
  15.         Console.WriteLine("\tNo badges."); 
    16. 
  
  
  
  16.     } 
    17. 
  
  
  
  17. }   
    18.

结果如下：

 
 
 
    
  
  
  
  1. John Doe has badges: 
    2. 
  
  
  
  2.         Badge: 2 
    3. 
  
  
  
  3.         Badge: 7 
    4. 
  
  
  
  4. Sue Smith has badges: 
    5. 
  
  
  
  5.         Badge: 5 
    6. 
  
  
  
  6. Jane Doe has badges: 
    7. 
  
  
  
  7.         No badges.
    8.

如果你想进步一强化对Join 和 GroupJoin 区别的了解，可以再一次看看上面两个例子输入的结果。

网页标题：LINQ联接序列的五种简单方法
转载注明：http://www.shufengxianlan.com/qtweb/news36/314786.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

电子商务知识

同城分类信息

成都app开发公司　　 　微信公众号开发　　 　成都网站设计　　 　西部信息服务器托管　　 　成都酒店服定制　　 　整合营销　　 　雅安托管服务器　　 　域名注册　　 　微信小程序开发　　 　LED网站设计方案　　 　成都标志设计　　 　梓潼网站设计　　 　娃娃鱼鱼苗　　 　云主机　　 　橡塑保温管　　 　成都能净科技　　 　成都艺考培训　　 　子晨木包装箱　　 　网页设计制作　　 　消防工程