对于昨天的连接还有一个知识点没有说，那就是分组连接。是11.5中的内容，补上。
分组连接的格式：join 元素 in 序列
on 条件表达式
into 新的序列
内连接和分组连接之间的一个重要差异(即分组连接和普通分组之间的差异)是，对于分组连接来说，在左边序列和结果序列之间是一对一的对应关系，即使左边序列中的某些元素在右边序列没有任何匹配的元素，也无所谓。这是非常重要的，有时会用于模拟SQL的左外连接。在左边元素不匹配任何右边元素的时候，嵌入序列就是空的。与内连接一样，分组连接要对右边序列进行缓冲，而对左边序列进行流处理。看代码吧。
1 //使用分组连接
2 var result7 = from box in boxList
3 join item in list on box.jewelleryType equals item.Type into items
4 select new { box, items };
5 //使用分组连接给我的感觉就好像将一系列的珠宝(具有相同属性值)，进行打包，当然生成的也是一个序列，而上
6 //述中的box则作为存放这些一些相同属性珠宝的标识
7 Console.WriteLine(result7.Count());
8
9 foreach (var re in result7)
10 {
11 Console.WriteLine(re.box.BoxName);
12 foreach (var item in re.items)
13 {
14 Console.WriteLine(item.Price);
15 }
16 }
这里的代码是接着昨天的代码的，哈哈，可能要看看上一篇文章。
- 使用多个from子句进行交叉连接和合并序列
到目前为止，我们学到的连接都是相等连接--左边序列中的元素和右边序列要进行匹配。交叉连接不在序列之间执行任何匹配操作，它只尽可能列出所有的可能。我们新建一个类，叫Customer
1 class Customer
2 {
3 public string Name { get; set; }
4 }
1 List<Jewellery> list = new List<Jewellery>()
2 {
3 new Jewellery() {Type=Jewellery.JewelleryType.Bracelet,State=Jewellery.JewelleryState.Repair,Price=100 },
4 new Jewellery() {Type=Jewellery.JewelleryType.Necklace,State=Jewellery.JewelleryState.Sold,Price=200 },
5 new Jewellery() {Type=Jewellery.JewelleryType.Ring,State=Jewellery.JewelleryState.Stock,Price=300 },
6 new Jewellery() {Type=Jewellery.JewelleryType.Necklace,State=Jewellery.JewelleryState.Sold,Price=400 },
7 new Jewellery() {Type=Jewellery.JewelleryType.Bracelet,State=Jewellery.JewelleryState.Stock,Price=500 },
8 new Jewellery() {Type=Jewellery.JewelleryType.Ring,State=Jewellery.JewelleryState.Repair,Price=600 }
9 };
10
11 List<Customer> ctrList = new List<Customer>()
12 {
13 new Customer() {Name="111" },
14 new Customer() {Name="222" },
15 new Customer() {Name="333" },
16 new Customer() {Name="444" },
17 new Customer() {Name="555" }
18 };
19
20 var result9 = from ctr in ctrList
21 from jly in list
22 select new { ctr, jly };
23 Console.WriteLine(result9.Count());
结果为30,因为珠宝有6件，顾客有5人，5*6=30。可见，使用两个from子句可能交叉连接返回所有组合的序列。
- 使用group...by子句进行分组
格式：group 元素 by 关键字
grouping表达式通过其键来决定序列如何分组。整个结果是一个序列，序列中的每个元素本身就是投影后元素的序列，还具有一个Key属性，即用于分组的键。下面来做一个操作，用珠宝的类型进行分组。
1 var result10 = from jly in list
2 group jly by jly.Type;
3
4 Console.WriteLine(result10.Count());
5
6 foreach (var jlys in result10)
7 {
8 Console.WriteLine(jlys.Key);
9 foreach(var jly in jlys)
10 {
11 Console.WriteLine(jly.Price);
12 }
13 }
感觉和使用join...into子句出来的效果是一样的，但是使用group...by更能让人理解。
- 查询延续
查询延续提供了一种方式，把一个查询表达式的结果用作另一个查询表达式的初始序列。它可以应用于group..by和select子句上，语法对于两者是一样的，只需要使用上下文关键字into，如要查询每种类型珠宝的数量，可以这样表示。
1 var result11 = from jly in list
2 group jly by jly.Type into jlys
3 select new { Type = jlys.Key, Count = jlys.Count() };
4
5 foreach(var item in result11)
6 {
7 Console.WriteLine(item.Type);
8 Console.WriteLine(item.Count);
9 }
结果为：
表明每一种类型都有两件珠宝。
- 使用LINQ表达式还是使用扩展方法
对于如何选择，每个心中都有数，这里只说下两者的关系。
每个查询表达式都可能使用扩展方法来表示，但很多LING操作在C#中不存在等价的查询表达式。
请斧正，抱一个学习的心态认真地做一件事情。