Linq 简明教程

一个简单的实例

    static void Main(string[] args)
         {
             string[] names = { "Alonso", "Zheng", "Jones", "Small",
 "Ruiz", "Hsieh", "Jorgenson", "Ilyich", "Samba", "Fatimah" };

             var queryResults = from a in names
                                where a.StartsWith("J")
                                select a;

             Console.WriteLine("Names beginning with S:");

             foreach (var item in queryResults)
             {
                 Console.WriteLine(item);
             }

             Console.ReadLine();
         }   

输出结果：

说明:

该语句包括4 个部分：以var 开头的结果变量声明，使用查询表达式给该结果变量赋值，查询表达式包含from 子句、where 子句和select 子句

• var 是C#中的一个新关键字，用于声明一般的变量类型，特别适合于包含LINQ查询的结果。var 关键字告诉C#编译器，根据查询推断结果的类型。这样，就不必提前声明从LINQ
  查询返回的对象类型了——编译器会推断出该类型。如果查询返回多个条目，该变量就是查询数据源中的一个对象集合(在技术上它并不是一个集合，只是看起来像是集合而已)
• 本例中的数据源是前面声明的字符串数组names。变量a 只是数据源中某一元素的代表，类似于foreach 语句后面的变量名。指定from 子句，就可以只查找集合的一个子集，而不用迭代所有的元素。
• 可以在where 子句中指定能应用于数据源中各元素的任意布尔(true 或false)表达式。实际上，where 子句是可选的，甚至可以忽略，但在大多数情况下，都要指定where 条件，把结果限制为我们需要的数据。where 子句称为LINQ 中的限制运算符， 因为它限制了查询的结果。
• select 子句是必须的，因为必须指定结果集中有哪些元素。这个结果集并不是很有趣，因为在结果集的每个元素中都只有一项name。如果结果集中有比较复杂的对象，使用select 子句的有效性就
  比较明显，不过在们还是先完成这个示例。

除了查询语句，还有一种是 方法语句：

 var queryResults = names.Where(n => n.StartsWith("S"));

得到的效果和查询语句一样

说明：

C#编译器把Lambda 表达式n => n.StartsWith("S"))编译为一个匿名方法，Where()在names 数组的每个元素上执行这个方法。如果Lambda 表达式给某个元素返回true，该元素就包含在Where()返回的结果集中。

 

 为查询结果排序： 谁用 orderby 语句

    var queryResults =
                 from n in names
                 where n.StartsWith("S")
                 orderby n
                 select n;

结果：

注意: 与where 子句一样，orderby 子句也是可选的

orderby 子句默认为升序(A 到Z)，但可以添加descending 关键字，以便指定降序(Z 到A)

orderby a descending

方法语法 排序

 var queryResults = names.OrderBy(n => n).Where(n => n.StartsWith("J"));

说明：

需要把一个Lambda 表达式传送给OrderBy()方法，告诉它用于排序的函数是什么。在们传送了最简单的Lambda 表达式n => n，因为只需要按照元素本身排序。

 

逆序排序：使用 OrderByDescending()

 var queryResults = names.OrderByDescending(n => n).Where(n => n.StartsWith("S"));

查询复杂的对象：

 

 namespace LinqTest
 {
     class Customer
     {
         public string ID { get; set; }
         public string City { get; set; }
         public string Province { get; set; }
         public decimal Sales { get; set; }

         //重写 ToString() 方法
         public override string ToString()
         {
             return "ID: " + ID + " City: " + City + " Province: " + Province + " Sales: " + Sales;
         }
     }

     class Program
     {
         static void Main(string[] args)
         {
             List<Customer> customers = new List<Customer>(){
                 new Customer{ID="A",City="北京",Province="北京",Sales=},
                 new Customer{ID="B",City="成都",Province="四川",Sales=},
                 new Customer{ID="C",City="乐山",Province="四川",Sales=},
                 new Customer{ID="D",City="绵阳",Province="四川",Sales=},
                 new Customer{ID="E",City="杭州",Province="浙江",Sales=},
                 new Customer{ID="F",City="绍兴",Province="浙江",Sales=},
                 new Customer{ID="G",City="宁波",Province="浙江",Sales=},
                 new Customer{ID="F",City="舟山",Province="浙江",Sales=},
             };
             var queryResults = from c in customers
                                where c.Province == "四川"  //选取省份为四川的
                                select c;
             //输出结果
             foreach (var item in queryResults)
             {
                 Console.WriteLine(item);
             }
             Console.ReadKey();
         }
     }
 }

结果：

说明：

这个查询应很眼熟，在其他示例中使用的也是from ... where ... select 查询，只是结果列表中的每一项都是一个完整对象(Customer)，而不是简单的string 或int

投影：在查询中创建新对象 

 　　　　　　　　　　　　　　　　　　var queryResults = from c in customers
                                where c.Province == "四川"  //选取省份为四川的
                                select c.City;  //只选取 Customer类中的City属性

结果：

若要提取对象中的多个属性则可：

1　　　　　　　　　　　　　　　　　　 var queryResults = from c in customers
                                where c.Province == "四川"  //选取省份为四川的
                                select new { c.City, c.Province };  //选取多个值的时候需要用  select new {  } 

结果：

说明：

 这里在select 子句中直接使用C#匿名类型创建语法，创建一个未命名的对象类型，它带有City、Province属性。select 子句创建了新对象。这样，只会复制这2个属性，完成处理查询的不同阶段。

 

投影: 方法语法

 

var queryResults = customers.Where(c => c.Province == "四川").Select(c => new { c.City, c.Province });

结果和上面一样

 多级排序：

查询语法：

处理了带多个属性的对象后，就要考虑另一种情形了：按一个字段给查询结果排序是不够的，

需要查询管理，先安装 省份 排序，再按照 城市 排序

 

     　　　　var queryResults = from c in customers
                                orderby c.Province, c.City
                                select c;

结果：  先安装 省份 排序，再按照 城市 排序

 多级排序之　方法语法： 使用 ThenBy 语句

  var queryResults = customers.OrderBy(c => c.Province)
                 .ThenBy(c => c.City)
                 .Select(c => c);

结果同上

分组查询：

若想查出每个省份的总销售额，则使用分组查询

1　　　　　　 var queryResults = from c in customers
                                group c by c.Province into cg
                                select new { TotalSales = cg.Sum(c => c.Sales), Province = cg.Key };

             //对新得到的结果集在进行 选取相关值
             var orderedResults = from t in queryResults   //t 只是个参数而已，随便命名
                                  orderby t.TotalSales descending
                                  select t;

结果：

说明：

分组查询中的数据通过一个键(key)字段来分组，每个组中的所有成员都共享这个字段值。在这个例子中，键字段是　c.Province

要计算每个组的总和，应生成一个新的结果集 cg

在 select 子句中，投影了一个新的匿名类型，其属性是总销售量(通过引用cg 结果集来计算)和组的键值，后者是用特殊的组Key 来引用的

Join语句：

 namespace LinqTest
 {
     class Customer
     {
         public string ID { get; set; }
         public string City { get; set; }
         public string Province { get; set; }
         public decimal Sales { get; set; }

         //重写 ToString() 方法
         public override string ToString()
         {
             return "ID: " + ID + " City: " + City + " Province: " + Province + " Sales: " + Sales;
         }
     }

     class Order
     {
         public string ID { get; set; }
         public decimal Amount { get; set; }
     }

     class Program
     {
         static void Main(string[] args)
         {
             List<Customer> customers = new List<Customer>(){
                 new Customer{ID="A",City="北京",Province="北京",Sales=},
                 new Customer{ID="B",City="成都",Province="四川",Sales=},
                 new Customer{ID="C",City="乐山",Province="四川",Sales=},
                 new Customer{ID="D",City="绵阳",Province="四川",Sales=},
                 new Customer{ID="E",City="杭州",Province="浙江",Sales=},
                 new Customer{ID="F",City="绍兴",Province="浙江",Sales=},
                 new Customer{ID="G",City="宁波",Province="浙江",Sales=},
                 new Customer{ID="F",City="舟山",Province="浙江",Sales=},
             };

             List<Order> orders = new List<Order>()
             {
                 new Order{ID="A",Amount = },
                 new Order{ID="B",Amount=},
                 new Order{ID="C",Amount = },
             };

             var queryResults = from c in customers
                                join o in orders on c.ID equals o.ID      //相当于 SQL中的 join 语句
                                select new { c.ID, c.City, SalesBefore = c.Sales, NewOrder = o.Amount, SalesAfter = c.Sales + o.Amount };
             //创建新对象  包含属性 ID City SalesBefore, NewOrder ,SalesAfter 几个属性

             foreach (var item in queryResults)
             {
                 Console.WriteLine(item);
             }
             Console.ReadKey();
         }
     }
 }

结果：

 　　　　　　　　var queryResults = from c in customers
                                join o in orders on c.ID equals o.ID      //相当于 SQL中的 join 语句
                                select new { c.ID, c.City, SalesBefore = c.Sales, NewOrder = o.Amount, SalesAfter = c.Sales + o.Amount };
             //创建新对象  包含属性 ID City SalesBefore, NewOrder ,SalesAfter 几个属性

说明：

查询使用join 关键字通过Customer 类和Order 类的ID 字段，把每个顾客与其对应的订单连接起来

equals 关键字指定另一个集合中的对应字段。查询结果仅包含两个集中ID 字段值相同的对象数据。

select 语句投影了一个带指定属性的新数据类型，因此可以清楚地看到最初的总销售量、新订单和最终的新总销售量：