21.C#序列过虑、排序、let子句和连接(十一章11.3-11.5)

　　哈哈，隔了一个星期，再怎么样都要发一篇，要多看书啊，书不能停~~~

• 使用where子句进行过虑

　　where子句的语法格式如下：where 过虑表达式

　　例子：新建一个珠宝类，如下：

 class Jewellery
 {
     /// <summary>
     /// 珠宝类型
     /// <list type="Ring">戒指</list>
     /// <list type="Necklace">项链</list>
     /// <list type="Bracelet">手链</list>
     /// </summary>
     public enum JewelleryType
     {
         Ring,
         Necklace,
         Bracelet
     }
     /// <summary>
     /// 当前珠宝状态
     /// <list type="Stock">存货</list>
     /// <list type="Repair">修理中</list>
     /// <list type="Sold">已售出</list>
     /// </summary>
     public enum JewelleryState
     {
         Stock,
         Repair,
         Sold
     }
     public JewelleryType Type { get; set; }
     public double Price { get; set; }
     public JewelleryState State { get; set; }
 }

　　再我们使用一个List来做容器，通过LINQ来过虑。

 List<Jewellery> list = new List<Jewellery>()
 {
     new Jewellery() {Type=Jewellery.JewelleryType.Bracelet,State=Jewellery.JewelleryState.Repair,Price= },
     new Jewellery() {Type=Jewellery.JewelleryType.Necklace,State=Jewellery.JewelleryState.Sold,Price= },
     new Jewellery() {Type=Jewellery.JewelleryType.Ring,State=Jewellery.JewelleryState.Stock,Price= },
     new Jewellery() {Type=Jewellery.JewelleryType.Necklace,State=Jewellery.JewelleryState.Sold,Price= },
     new Jewellery() {Type=Jewellery.JewelleryType.Bracelet,State=Jewellery.JewelleryState.Stock,Price= },
     new Jewellery() {Type=Jewellery.JewelleryType.Ring,State=Jewellery.JewelleryState.Repair,Price= }
 };

 //查找价格大于300的手链
 var result = from item in list
              where item.Price >  && item.Type == Jewellery.JewelleryType.Bracelet
              select item;
 //转换为list.Where(item => item.Price > 300).Where(item => item.Type == Jewellery.JewelleryType.Bracelet);
 Console.WriteLine(result.Count());

 //记录当前正在修理中的珠宝总值
 var result1 = (from item in list
                where item.State == Jewellery.JewelleryState.Repair
                select item).Sum(item => item.Price);
 //转换为list.Where(item => item.State == Jewellery.JewelleryState.Repair).Sum(item => item.Price);
 Console.WriteLine(result1);

 Console.ReadKey();

• 退化的查询表达式

 var resutl2 = from item in list
               select item;
 //这个就是所谓的退化表达式，编译器会故意生成一个对Select方法的调用，即使它什么都没有做，但result2和list有很大的不同，
 //两个序列返回的数据是相同的，但是Select方法的结果只是数据项的序列，而不是数据源本身。查询表达式的结果和源数据永远不会是同一个对象
 //当有其它的操作的时候，就不用为编译器保留一个"空操作"Select子句

• 使用orderby子句进行排序

 //按价格排序，从大到小
 var resutl3 = from item in list
               orderby item.Price descending
               select item;
 //转换为list.OrderByDescending(item => item.Price);

 //先用价格再按状态排序
 var result4 = from item in list
               orderby item.Price, item.State
               select item;

• let子句

　　let子句只不过引入一个新的范围变量，它的值是基于其它范围变量，语法格式：let 标识符 = 表达式

 //货品是用RMB的，现在使用HK来记录，使用投影返回匿名对象的序列
 var result5 = from item in list
               let hk = item.Price / 0.8
               select new { hk = hk, item = item };

　　let操作符对一个表达式进行求值，并引入新的范围变量

• 连接

　　相应于数据库中的概念，使用两张表，这里是使用两个序列，通过匹配两者之间的数据行来创建结果。

1. 使用join子句的内连接

　　内连接涉及两个序列。一个键选择器表达式应用于第1个序列的每一个元素，另外一个键选择器(可能完全不同)应用于第二个序列的每一个元素。连接的结果是一个包含所有配对元素的序列，配对的规则是第1个元素的键与第2个元素的键相同。

　　连接的格式：join 右边序列元素 in 右边序列

　　　　　　　　on 左边序列元素的key equals 右边序列元素的key

 /// <summary>
 /// 用于存放珠宝的盒子
 /// </summary>
 class Box
 {
     /// <summary>
     /// 盒子有一个珠宝类型的属性，与要放的珠宝类型一致
     /// </summary>
     public Jewellery.JewelleryType jewelleryType { get; set; }
     public string BoxName { get; set; }
 }

 //打印每个珠宝存放的盒子,珠宝的状态要是存货
 var result6 = from box in boxList
               join item in list
               on box.jewelleryType equals item.Type
               where item.State == Jewellery.JewelleryState.Stock
               select new { BoxName = box.BoxName, Price = item.Price };

 result6.ToList().ForEach(item => Console.WriteLine("位置:" + item.BoxName + ";" + "价格:" + item.Price));

　　结果如下

　　可见在box1中放了一件价格为500的珠宝，在box3中放着一个价格为300的珠宝。这里作为两个序列的key的是珠宝的类型Jewellery.JewelleryType

　　请斧正。