Linq 简明教程

一个简单的实例

 1    static void Main(string[] args)

 2         {

 3             string[] names = { "Alonso", "Zheng", "Jones", "Small",

 4 "Ruiz", "Hsieh", "Jorgenson", "Ilyich", "Samba", "Fatimah" };

 5 

 6             var queryResults = from a in names

 7                                where a.StartsWith("J")

 8                                select a;

 9             

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

11             

12             foreach (var item in queryResults)

13             {

14                 Console.WriteLine(item);

15             }

16            

17             Console.ReadLine();

18         }   

输出结果：

说明:   

该语句包括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 语句

1    var queryResults =

2                 from n in names

3                 where n.StartsWith("S")

4                 orderby n 

5                 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"));

 

查询复杂的对象：

 

 1 namespace LinqTest

 2 {

 3     class Customer

 4     {

 5         public string ID { get; set; }

 6         public string City { get; set; }

 7         public string Province { get; set; }

 8         public decimal Sales { get; set; }

 9 

10         //重写 ToString() 方法

11         public override string ToString()

12         {

13             return "ID: " + ID + " City: " + City + " Province: " + Province + " Sales: " + Sales;

14         }

15     }

16 

17     class Program

18     {

19         static void Main(string[] args)

20         {

21             List<Customer> customers = new List<Customer>(){

22                 new Customer{ID="A",City="北京",Province="北京",Sales=9999},

23                 new Customer{ID="B",City="成都",Province="四川",Sales=6666},

24                 new Customer{ID="C",City="乐山",Province="四川",Sales=3333},

25                 new Customer{ID="D",City="绵阳",Province="四川",Sales=2222},

26                 new Customer{ID="E",City="杭州",Province="浙江",Sales=5555},

27                 new Customer{ID="F",City="绍兴",Province="浙江",Sales=3333},

28                 new Customer{ID="G",City="宁波",Province="浙江",Sales=7777},

29                 new Customer{ID="F",City="舟山",Province="浙江",Sales=8888},

30             };

31             var queryResults = from c in customers

32                                where c.Province == "四川"  //选取省份为四川的

33                                select c;

34             //输出结果

35             foreach (var item in queryResults)

36             {

37                 Console.WriteLine(item);

38             }

39             Console.ReadKey();      

40         }    

41     }

42 }

结果：

说明：

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

 

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

1 　　　　　　　　　　　　　　　　　　var queryResults = from c in customers

2                                where c.Province == "四川"  //选取省份为四川的

3                                select c.City;  //只选取 Customer类中的City属性

结果：

 

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

1　　　　　　　　　　　　　　　　　　 var queryResults = from c in customers

2                                where c.Province == "四川"  //选取省份为四川的

3                                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 });

结果和上面一样

 

  多级排序：

查询语法：

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

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

 

1     　　　　var queryResults = from c in customers

2                                orderby c.Province, c.City

3                                select c;

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

 

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

1  var queryResults = customers.OrderBy(c => c.Province)

2                 .ThenBy(c => c.City)

3                 .Select(c => c);

结果同上

 

分组查询：

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

1　　　　　　 var queryResults = from c in customers  

2                                group c by c.Province into cg

3                                select new { TotalSales = cg.Sum(c => c.Sales), Province = cg.Key };

4 

5             //对新得到的结果集在进行 选取相关值

6             var orderedResults = from t in queryResults   //t 只是个参数而已，随便命名

7                                  orderby t.TotalSales descending

8                                  select t;

结果：

说明：

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

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

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

Join语句：

 

 1 namespace LinqTest

 2 {

 3     class Customer

 4     {

 5         public string ID { get; set; }

 6         public string City { get; set; }

 7         public string Province { get; set; }

 8         public decimal Sales { get; set; }

 9 

10         //重写 ToString() 方法

11         public override string ToString()

12         {

13             return "ID: " + ID + " City: " + City + " Province: " + Province + " Sales: " + Sales;

14         }

15     }

16 

17     class Order

18     {

19         public string ID { get; set; }

20         public decimal Amount { get; set; } 

21     }

22 

23     class Program

24     {

25         static void Main(string[] args)

26         {

27             List<Customer> customers = new List<Customer>(){

28                 new Customer{ID="A",City="北京",Province="北京",Sales=9999},

29                 new Customer{ID="B",City="成都",Province="四川",Sales=6666},

30                 new Customer{ID="C",City="乐山",Province="四川",Sales=3333},

31                 new Customer{ID="D",City="绵阳",Province="四川",Sales=2222},

32                 new Customer{ID="E",City="杭州",Province="浙江",Sales=5555},

33                 new Customer{ID="F",City="绍兴",Province="浙江",Sales=3333},

34                 new Customer{ID="G",City="宁波",Province="浙江",Sales=7777},

35                 new Customer{ID="F",City="舟山",Province="浙江",Sales=8888},

36             };

37 

38             List<Order> orders = new List<Order>()

39             {

40                 new Order{ID="A",Amount = 1111},

41                 new Order{ID="B",Amount=2222},

42                 new Order{ID="C",Amount = 3333},

43             };

44 

45 

46             var queryResults = from c in customers

47                                join o in orders on c.ID equals o.ID      //相当于 SQL中的 join 语句

48                                select new { c.ID, c.City, SalesBefore = c.Sales, NewOrder = o.Amount, SalesAfter = c.Sales + o.Amount };

49             //创建新对象  包含属性 ID City SalesBefore, NewOrder ,SalesAfter 几个属性

50 

51 

52             foreach (var item in queryResults)

53             {

54                 Console.WriteLine(item);

55             }

56             Console.ReadKey();      

57         }    

58     }

59 }

 

结果：

 

1 　　　　　　　　var queryResults = from c in customers

2                                join o in orders on c.ID equals o.ID      //相当于 SQL中的 join 语句

3                                select new { c.ID, c.City, SalesBefore = c.Sales, NewOrder = o.Amount, SalesAfter = c.Sales + o.Amount };

4             //创建新对象  包含属性 ID City SalesBefore, NewOrder ,SalesAfter 几个属性

说明：

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

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

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