Linq 简明教程

最新推荐文章于 2024-11-16 19:38:27 发布

baai4968

最新推荐文章于 2024-11-16 19:38:27 发布

阅读量122

点赞数

文章标签： c#

原文链接：http://www.cnblogs.com/TangPro/p/3501836.html

版权

一个简单的实例

 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 几个属性