延时执行的enumerable类方法
linq标准查询运算法是依靠一组扩展方法来实现的。而这些扩展方法分别在system.linq.enumerable和system.linq.queryable这连个静态类中定义。
enumerable的扩展方法采用线性流程，每个运算法会被线性执行。这种执行方法如果操作类似关系型数据库数据源，效率会非常低下，所以queryable重新定义这些扩展方法，把linq表达式拆解为表达式树，提供程序就可以根据表达式树生成关系型数据库的查询语句，即sql命令，然后进行相关操作。
每个查询运算符的执行行为不同，大致分为立即执行和延时执行。延时执行的运算符将在枚举元素的时候被执行。
enumerable类位于程序集system.core.dll中，system.linq命名空间下，并且直接集成自system.object，存在于3.5及以上的.net框架中。enumerable是静态类，不能实例化和被继承，其成员只有一组静态和扩展方法。
linq不仅能够查询实现ienumerable<t>或iqueryable<t>的类型，也能查询实现ienumerable接口的类型。
理解linq首先必须理解扩展方法
msdn是这样规定扩展方法的：“扩展方法被定义为静态方法，但它们是通过实例方法语法进行调用的。 它们的第一个参数指定该方法作用于哪个类型，并且该参数以 this 修饰符为前缀。”
下面给个扩展方法的例子如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
using system;using system.collections.generic;using system.linq;using system.text;namespace 扩展方法{ /// <summary> /// 为string类型定义一个扩展方法 /// </summary> static class helper { public static string myextenmethod(this string s) { return s.substring(0, 2); } } class program { static void main(string[] args) { string s = "扩展方法示例"; console.writeline(s.myextenmethod());//调用 console.readkey(false); } }} |
程序的运行结果如下：
为了方便理解和记忆，将常用的延时执行的enumerable类方法成员分了下组，具体如下：
1.take用于从一个序列的开头返回指定数量的元素
2.takewhile 用于获取指定序列从头开始符合条件的元素，直到遇到不符合条件的元素为止
3.skip跳过序列中指定数量的元素
4.skipwhile 用于跳过序列总满足条件的元素，然会返回剩下的元素
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
using system;using system.collections.generic;using system.linq;using system.text;namespace 延时执行的enumerable类方法{ class program { static void main(string[] args) { string[] names = { "debuglzq","debugman","sarah","jerry","tom","linda","m&m","jeffery"}; //1.take用于从一个序列的开头返回指定数量的元素 // //a.在数组上直接使用take方法 foreach (string name in names.take(3)) { console.write("{0} ", name); } console.writeline(); console.writeline("-----"); //b.在linq返回的ienumerable<t>序列上使用take方法 var query = from string name in names where name.length <=3 select name; foreach (string name in query.take(1)) { console.write("{0} ",name); } console.writeline(); console.writeline("----------------------------"); console.readkey(false); //2.takewhile 用于获取指定序列从头开始符合条件的元素，直到遇到不符合条件的元素为止 // var takenames = names.takewhile(n => n.length>4); var takenames2 = names.takewhile((n,i)=>n.length<10&&i<3); foreach (string name in takenames) { console.write("{0} ", name); } console.writeline(); console.writeline("-----"); foreach (string name in takenames2) { console.write("{0} ", name); } console.writeline(); console.writeline("----------------------------"); console.readkey(false); //3.skip跳过序列中指定数量的元素 // foreach (string name in names.skip(5)) { console.write("{0} ", name); } console.writeline(); console.writeline("-----"); var query_skip = (from name in names where name.length >= 3 select name).skip(2); foreach (string name in query_skip.skip(2) ) { console.write("{0} ", name); } console.writeline(); console.writeline("----------------------------"); console.readkey(false); //4.skipwhile 用于跳过序列总满足条件的元素，然会返回剩下的元素 //跳过名字长度大于3的 var takenames_skipwhile = names.skipwhile(n => n.length >3); foreach (string name in takenames_skipwhile) { console.write("{0} ", name); } console.writeline(); console.writeline("-----"); var takenames_skipwhile2 = names.skipwhile((n,i)=>n.length>3&&i>2); foreach (string name in takenames_skipwhile2) { console.write("{0} ", name); } console.writeline(); console.writeline("----------------------------"); console.readkey(false); //小结take、skip获得第n到第m个元素 var names_takeandskip = names.skip(5).take(3); var names_takeandskip2 = (from name in names select name).skip(5).take(3); foreach (string name in names_takeandskip) { console.write("{0} ", name); } console.writeline(); console.writeline("-----"); foreach (string name in names_takeandskip2) { console.write("{0} ", name); } console.writeline(); console.writeline("----------------------------"); console.readkey(false); } }} |
程序中有详细的注释不再多做说明，程序运行结果如下：
5.reverse用于翻转序列中的元素的顺序
6.distinct过滤掉重复的元素
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
using system;using system.collections.generic;using system.linq;using system.text;namespace reverse_distinct等{ class program { static void main(string[] args) { string[] names = { "debuglzq", "jerry", "sarah", "jerry", "tom", "linda", "m&m", "jeffery" }; //5.reverse用于翻转序列中的元素的顺序 string str = "反转字符串"; var strre = str.tochararray().reverse(); var takenames = names.reverse(); foreach (var c in strre) { console.write(c); } console.writeline(); console.writeline("-----"); foreach (var c in takenames ) { console.writeline(c); } console.writeline("----------------------------"); console.readkey(false); //6.distinct 过滤掉重复的元素 var takenames_distinct = names.distinct(); foreach (var c in takenames_distinct) { console.writeline(c); } console.writeline("----------------------------"); console.readkey(false); } }} |
程序的运行结果如下：
7.union用于合并两个序列，并去掉重复项
8.concat用于连接两个序列，不会去掉重复项
9.intersect用于获得连个序列的交集
10.except用于获得两个结合的差集
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
using system;using system.collections.generic;using system.linq;using system.text;namespace union_concat_intersect_except{ /// <summary> /// debuglzq /// http://www.cnblogs.com/debuglzq /// </summary> class program { static void main(string[] args) { string[] names1 = { "debuglzq", "jerry", "sarah", "jerry", "tom", "linda", "m&m", "jeffery" }; string[] names2 = { "debuglzq", "jerry", "sarah" }; //7.union用于合并两个序列，并去掉重复项 var names_union = names1.union(names2); //8.concat用于连接两个序列，不会去掉重复项 var names_concat = names1.concat(names2); //9.intersect用于获得连个序列的交集 var names_intersect = names1.intersect(names2); //10.except用于获得两个结合的差集 var names_except = names1.except(names2); foreach (string name in names_union) { console.writeline(name); } console.writeline("-----"); console.readkey(false); foreach (string name in names_concat) { console.writeline(name); } console.writeline("-----"); console.readkey(false); foreach (string name in names_intersect) { console.writeline(name); } console.writeline("-----"); console.readkey(false); foreach (string name in names_except) { console.writeline(name); } console.writeline("-----"); console.readkey(false); } }} |
程序的运行结果如下：
11.range 用于生成指定范围内的“整数”序列
12.repeat用于生成指定数量的重复元素
13.empty 用于获得一个指定类型的空序列
14.defaultifempty 用于获得序列，如果为空，则添加一个默认类型元素
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
using system;using system.collections.generic;using system.linq;using system.text;namespace range_empty_defalultifempty{ /// <summary> /// debuglzq /// http://www.cnblogs.com/debuglzq /// </summary> class program { static void main(string[] args) { //11.range 用于生成指定范围内的“整数”序列 var num2 = enumerable.range(10, 15); //12.repeat用于生成指定数量的重复元素 var guest = new {name="橙子",age=25 }; var guests = enumerable.repeat(guest, 5); //13.empty 用于获得一个指定类型的空序列 var empty = enumerable.empty<string>(); //14.defaultifempty 用于获得序列，如果为空，则添加一个默认类型元素 //a var intempty = enumerable.empty<int>(); console.writeline(intempty.count()); console.writeline("-----------"); foreach (var n in intempty) { console.writeline(n); } console.writeline("-----------"); console.writeline(intempty.defaultifempty().count()); console.writeline("-----------"); foreach (var n in intempty.defaultifempty()) { console.writeline(n); } console.writeline("--------------------------"); console.readkey(false); //b string[] names = { "debuglzq", "debugman", "sarah", "jerry", "tom", "linda", "m&m", "jeffery" }; var query = from name in names where name == "lbj" select name; console.writeline(query.count()); console.writeline(query.defaultifempty().count());//默认为null foreach (var n in query.defaultifempty()) { console.writeline(n); } console.writeline("---------------"); console.readkey(false); //c指定一个默认值 foreach (var n in intempty.defaultifempty(100)) { console.writeline(n); } console.writeline("--------------------------"); console.readkey(false); foreach (var n in query.defaultifempty("james")) { console.writeline(n); } console.readkey(false); } }} |
程序的运行结果如下：
15.oftype筛选指定类型的元素
16.cast类型转换
17.asenumerable有些数据源类型不支持enumerable的部分查询关键字，需要转换下，譬如iqueryable
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
using system;using system.collections.generic;using system.linq;using system.text;using system.collections;namespace cast_oftype_asenumerable{ /// <summary> /// debuglzq /// http://www.cnblogs.com/debuglzq /// </summary> class program { static void main(string[] args) { arraylist names = new arraylist(); names.add("debuglzq"); names.add("jerry"); names.add(100); names.add(new {name="lzq",age=26}); names.add(new stack()); //15.oftype筛选指定类型的元素 var takenames = names.oftype<string>(); //16.cast类型转换 var takenames2 = names.oftype<string>().cast<string>(); //17.asenumerable var takenames3 = takenames2.asenumerable(); foreach (var name in takenames3) { console.write("{0} ",name); } console.readkey(false); } }} |
程序运行结果如下：
延时执行，顾名思义就是不是立即执行，即不是在查询语句定义的时候执行，而是在处理结果集(如遍历)的时候执行，在enumerable类方法成员中，除了本节总结的这常用的17个外，前面博文---linq基本子句 中总结的8个基本子句也都是延时执行的。注意延时执行的查询程序的执行流程。
立即执行的enumerable类方法
下面我们再来总结常用的立即执行的enumerable类方法和它们的常用用法。同样，为了便于理解和记忆，进行一下分组：
1.toarray序列转换成数组
2.tolist序列转换成list<t>
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
using system;using system.collections.generic;using system.linq;using system.text;namespace 立即执行的enumerable类方法成员{ class program { static void main(string[] args) { //1.toarray序列转换成数组 list<string> names =new list<string> { "debuglzq","sarah","jerry","jeffrey","m&m"}; string[] takenames = names.toarray(); string[] takenames2 = (from name in names where name.indexof("je")>-1 select name).toarray(); //2.tolist序列转换成list<t> string[] namesa = { "debuglzq", "sarah", "jerry", "jeffrey", "m&m" }; list<string> takenames_tolist = namesa.tolist(); list<string> takenames_tolist2 = (from name in namesa select name).tolist(); // } }} |
程序结果显而易见，所以没有写输出语句；
3.todictionary把序列转换为泛型dictionary<tkey,tvalue>
4.tolookup用于将序列转换为泛型lookup<tkey,tvalue>
dictionary和lookup是非常近似的一对类型，都通过“键”访问相关的元素，不同的是dictionary的key和value是一一对应关系，lookup的key和value是一对多关系，lookup没有公共构造函数，时能用tolookup构建，创建后也不能删除lookup中的元素。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
using system;using system.collections.generic;using system.linq;using system.text;namespace todictionary{ /// <summary> /// 3.todictionary把序列转换为泛型dictionary<tkey,tvalue> /// </summary> class program { static void main(string[] args) { list<guestinfo> glist = new list<guestinfo>() { new guestinfo(){name="jeffrey", age=33,tel="136********"}, new guestinfo(){ name="debuglzq", age=25,tel="187********"}, new guestinfo(){name="sarah", age=24,tel="159********"}, new guestinfo(){name="jerry", age=33,tel="135********"}, new guestinfo(){name="smith", age=33,tel="139********"} }; //todictionary把序列转换为泛型dictionary //todictionary重载了4个方法 //a.用name作为dictionary的“键”,guest为“value” dictionary<string, guestinfo> dictionary1 = glist.todictionary(guest => guest.name); foreach (var s in dictionary1 ) { console.writeline("键值{0}:{1} {2} {3}",s.key,s.value.name,s.value.age,s.value.tel ); } console.writeline("--------------------------------"); console.readkey(); //b.自定义比较器 dictionary<string,guestinfo> dictionary2=glist.todictionary(guest=>guest.name,new myequalitycomparer<string>()); foreach (var s in dictionary2) { console.writeline("键值{0}:{1} {2} {3}", s.key, s.value.name, s.value.age, s.value.tel); } console.writeline("--------------------------------"); console.readkey(); //c.用name作为dictionary的“键”,tel属性为"value" dictionary<string, string> dictionary3 = glist.todictionary(guest=>guest.name,g=>g.tel); foreach (var s in dictionary3) { console.writeline("键值{0}:{1}", s.key, s.value); } console.writeline("--------------------------------"); console.readkey(); //d.自定义比较器 dictionary<string, string> dictionary4 = glist.todictionary(guest=>guest.name,g=>g.tel,new myequalitycomparer<string>()); foreach (var s in dictionary4) { console.writeline("键值{0}:{1}", s.key, s.value); } console.writeline("------------------------------------------------------"); console.readkey(); /////////////// ///4.tolookup用于将序列转换为泛型lookup<tkey,tvalue>。 ///dictionary和lookup是非常近似的一对类型，都通过“键”访问相关的元素，不同的是dictionary的key和value是一一对应关系 ///lookup的key和value是一对多关系 ///lookup没有公共构造函数，时能用tolookup构建，创建后也不能删除lookup中的元素。 ///该方法也有4个原型，和上面的todictionary极像 /// //a. name的第一个字符(字符串)作key ilookup<string, guestinfo> lookup1 = glist.tolookup(guest => guest.name.substring(0, 1)); foreach (var k in lookup1) { console.writeline(k.key);//键值 foreach (var v in k) { console.write("{0},{1},{2}",v.name,v.age,v.tel ); } console.writeline(); } console.writeline("--------------------------------"); console.readkey(); //b自定义比较器 ilookup<string, guestinfo> lookup2 = glist.tolookup(guest => guest.name.substring(0, 1), new myequalitycomparer<string>()); foreach (var k in lookup2) { console.writeline(k.key);//键值 foreach (var v in k) { console.write("{0},{1},{2}", v.name, v.age, v.tel); } console.writeline(); } console.writeline("--------------------------------"); console.readkey(); //c ilookup<string, string> lookup3 = glist.tolookup(guest=>guest.name.substring(0,1),g=>g.name ); foreach (var k in lookup3) { console.writeline(k.key);//键值 foreach (var v in k) { console.write("{0} ", v); } console.writeline(); } console.writeline("--------------------------------"); console.readkey(); //d自定义比较器 ilookup<string, string> lookup4 = glist.tolookup(guest=>guest.name.substring(0,1),g=>g.name,new myequalitycomparer<string>()); foreach (var k in lookup4) { console.writeline(k.key);//键值 foreach (var v in k) { console.write("{0} ", v); } console.writeline(); } console.writeline("--------------------------------"); console.readkey(); } }} |
程序运行结果如下：
没有显示完全，后面一组输出和上面最后一组相同（只是使用了自定义的比较器）。
5.sequenceequal 比较两个序列是否相等
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
using system;using system.collections.generic;using system.linq;using system.text;namespace sequenceequal{ /// <summary> /// /// </summary> class program { static void main(string[] args) { //5.sequenceequal 比较两个序列是否相等 //a比较两个序列 string[] names1 ={ "debuglzq","sarah","jerry","jeffrey","m&m"}; list<string> names2 = new list<string> { "debuglzq", "sarah", "jerry", "jeffrey", "m&m" }; bool equalornot = names1.sequenceequal(names2); bool equalornot2 = names1.skip(3).take(2).sequenceequal(names2.take(3).skipwhile(n=>n.length==3)); console.writeline("{0},{1}",equalornot,equalornot2 ); console.writeline("----------------------------"); console.readkey(); //b自定义比较器 bool equalornot3 = names1.sequenceequal(names2, new myequalitycomparer<string>(names2.toarray())); console.writeline("{0}",equalornot3); console.readkey(); } }} |
自定义的比较器如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
using system;using system.collections.generic;using system.linq;using system.text;namespace sequenceequal{ //debuglzq提示： //如不知道具体的接口实现 //可以用vs提供的自动实现接口功能实现这个接口 class myequalitycomparer<t> : iequalitycomparer<t> { private string[] sec; public myequalitycomparer(string[] s) { sec = s; } #region iequalitycomparer<t> 成员 public bool equals(t x, t y) { string temp = x as string; if (x != null) { return sec.contains(temp); } return false; } public int gethashcode(t obj) { return obj.gethashcode(); } #endregion }} |
可以使用vs自动实现接口的智能提示，完成接口的实现。
接口的实现方式有“实现接口”和“显式实现接口”之分，上面这种实现方式即“显示接口”方式，“显示实现接口”最显著的特征是实现的接口方法加了个完全限定名，这样显式实现之后，无法通过具体的类名来访问接口方法，只能通过接口名来访问，这样可以隐藏类的复杂性。
程序运行结果如下：
6.first 返回序列第一个满足条件元素
7.firstordefault 返回序列第一个满足条件元素，如果没有找到则返回默认值
8.last
9.lastordefault
10.single返回序列中唯一的元素，如果序列中包含多个元素，会引发运行错误！
11.singleordefault 找出序列中满足一定条件的元素，如果序列为空则返回默认值， 如果序列中包含多个多个元素会引发运行错误！！
12.elementat 获得指定索引处的元素
13.elementatordefault 获得指定索引处的元素，如果超出索引，则返回元素类型的默认值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
using system;using system.collections.generic;using system.linq;using system.text;namespace first_firstordefault_last_lastordefault_elementat_elementatordefaul{ class program { static void main(string[] args) { //6.first string[] names = { "debuglzq", "sarah", "jerry", "jeffrey", "m&m" }; var item = names.first(); var item2 = names.first(n => n == "sarah"); console.writeline("{0},{1}",item,item2 ); console.readkey(); //7.firstordefault var item3 = names.firstordefault(); var item4 = names.firstordefault(n => n == "sarah"); console.writeline("{0},{1}", item3, item4); console.readkey(); //8.last var item5 = names.last(); var item6 = names.lastordefault(n => n == "sarah"); console.writeline("{0},{1}", item5, item6); console.readkey(); //9lastordefault var item7 = names.lastordefault(); var item8 = names.lastordefault(n => n == "sarah"); console.writeline("{0},{1}", item7, item8); console.readkey(); //10.single返回序列中唯一的元素，如果序列中包含多个元素，会引发运行错误！ try { var item9 = names.single(); } catch(exception ex) { console.writeline(ex.message); } // var item10 = names.single(n => n == "sarah"); console.writeline("{0}",item10 ); console.readkey(); //11.singleordefault 找出序列中满足一定条件的元素，如果序列为空则返回默认值， 如果序列中包含多个多个元素会引发运行错误！！ try { var item11 = enumerable.empty<string>().singleordefault(); console.writeline("{0}",item11);//不报错，如果序列为空就返回默认值 } catch (exception ex) { console.writeline(ex.message ); } try { var item12 = names.singleordefault(); console.writeline("{0}", item12);//报错，序列包含多行错误 } catch (exception ex) { console.writeline(ex.message); } var item13 = enumerable.empty<string>().defaultifempty("debuglzq").singleordefault(); console.writeline("{0}", item13); var item14 = names.singleordefault(n => n == "xxx"); console.writeline("{0}", item14); console.readkey(); //12elementat 获得指定索引处的元素 var item15 = names.elementat(3); console.writeline("{0}", item15); console.readkey(); //13elementatordefault 获得指定索引处的元素，如果超出索引，则返回元素类型的默认值 var item16 = names.elementatordefault(3); var item17 = names.elementatordefault(100); console.writeline("{0},{1}",item16,item17); console.readkey(); } }} |
程序运行结果如下：
14.all序列中的所有元素是否都满足条件
15.any序列中的元素是否存在或满足条件
16.contains确定元素是否在序列中
17.count序列包含元素的数量
18.longcount获取一个int64类型的元素数量
19.aggregate将序列元素进行累加
20.sum序列之和
21.average序列平均值
22.min序列的最小值
23.max序列的最大值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
using system;using system.collections.generic;using system.linq;using system.text;namespace all_any_count_longcount_aggregate_sumaverage_min_max{ class program { static void main(string[] args) { string[] names = { "debuglzq", "sarah", "jerry", "jeffrey", "m&m" }; //14all序列中的所有元素是否都满足条件 bool b1 = names.all(s=>s.gettypecode()==typecode.string ); bool b2 = names.all(s=>s.indexof("s")>-1); console.writeline("{0},{1}",b1,b2); console.readkey(); console.writeline("----------------------"); //15any序列中的元素是否存在或满足条件 bool p1 = names.any(); bool p2 = names.any(s => s.indexof("s")>-1); console.writeline("{0},{1}", p1, p2); console.readkey(); console.writeline("----------------------"); //16contains确定元素是否在序列中 //a bool q1 = names.contains("mm"); //b自定义比较函数 bool q2 = names.contains("mm", new myequalitycomparer<string>()); console.writeline("{0},{1}", q1, q2); console.readkey(); console.writeline("----------------------"); //17count序列包含元素的数量 int i1 = names.count(); int i2 = names.count(n => n.length == 5); console.writeline("{0},{1}", i1, i2); console.readkey(); console.writeline("----------------------"); //18longcount获取一个int64类型的元素数量 long j1 = names.longcount(); long j2 = names.longcount(n => n.length == 5); console.writeline("{0},{1}",j1, j2); console.readkey(); console.writeline("----------------------"); //19aggregate将序列元素进行累加 int[] nums = { 10,20,30,40,50}; int a1 = nums.aggregate((n1,n2)=>n1+n2);//150 int a2 = nums.aggregate(50,(n1,n2)=>n1+n2);//200 console.writeline("{0},{1}", a1, a2); string s1 = names.aggregate((name1,name2)=>string.format("{0}、{1}",name1,name2)); string s2= names.aggregate("the result is ",(name1, name2) => string.format("{0}、{1}", name1, name2)); console.writeline("{0}", s1); console.writeline("{0}", s2); console.readkey(); console.writeline("----------------------"); //20sum序列之和 int sum = nums.sum(); //21average序列平均值 double avg = nums.average(); //22min序列的最小值 int min = nums.min(); //23max序列的最大值 int max=nums.max(); console.writeline("{0},{1},{2},{3}", sum, avg,min,max); console.readkey(); } }} |
程序运行结果如下：
