LINQ学习之旅——第一站"LTO"之非延时标准查询操作符(下)

　　紧接着昨天的内容，把剩余的几个非延时标准查询操作符讲解一下。

　　12.ElementAt操作符

　　(1)作用：用于返回序列中指定位置的元素；

　　(2)方法原型：

　　　　public static T ElementAt<T>(

　　　　this IEnumerable<T> source,

　　　　int index);

　　(3)原型说明：参数index用于指定元素在序列中的位置，位置索引以0开始，若指定的索引小于0或者大于或者等于序列中元素的个数，则操作符ElementAt抛出异常；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

            Console.WriteLine("调用Element操作符：");
            Console.WriteLine("------------------------------------");

            Employee employee = employees.ElementAt(4);

            Console.WriteLine("雇员序列中的索引为4的元素：");
            Console.WriteLine(employee.ToString());

            Console.Read();
        }

结果：

　　13.ElementAtOrDefault操作符

　　(1)作用：用于返回序列中指定位置的元素，如果指定索引的值不合法，则返回一个相关类型默认值元素；

　　(2)方法原型：

　　　　public static T ElementAtOrDefault<T>(

　　　　this IEnumerable<T> source,

　　　　int index);

　　(3)原型说明：实现原理和操作符ElementAt一样，唯一区别在当索引值小于0或者大于或者等于序列中元素个数时，即索引值非法情况，操作符ElementAt会抛出异常。而操作符ElementAtOrDefault则返回T类型的默认值default(T)；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

            Console.WriteLine("调用ElementAtOrDefault操作符：");
            Console.WriteLine("------------------------------------");

            Employee employee1 = employees.ElementAtOrDefault(7);

            Console.WriteLine("雇员序列中的索引为7的元素：");
            Console.WriteLine(employee1);

            Console.Read();
        }

结果：

　　14.Any操作符

　　(1)作用：判断输入序列中是否含有元素或者含有满足条件的元素；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static bool Any<T>(

　　　　this IEnumerable<T> source); 

　　　　②原型定义：

　　　　public static bool Any<T>(

　　　　this IEnumerable<T> source,

　　　　Func<T,bool> predicate); 

　　(3)原型说明：第一种方法原型接收一个输入序列source，如果序列中至少有一个元素，操作符返回true，否则false。第二种原型比前一种多了一个委托参数predicate，只要至少有一个元素使得委托predicate的返回值为true，则操作符Any返回值就为true，否则为false；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

//Any第一个原型
         Console.WriteLine("调用Any操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

bool flag = employees.Any();
if (flag)
                Console.WriteLine("雇员序列中至少有一个元素！");
else
                Console.WriteLine("雇员序列为空！");

            Console.WriteLine("***************************************************");

//Any第二个原型
          Console.WriteLine("调用Any操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

bool flag1 = employees.Any(e=>e.Id=="0005");
if (flag1)
                Console.WriteLine("至少有一个0005号雇员！");
else
                Console.WriteLine("没有0005好雇员！");

            Console.Read();
        }

结果：

　　15.All操作符

　　(1)作用：用于判断输入序列中所有元素是否都满足指定条件；

　　(2)方法原型：

　　　　public static bool All<T>(

　　　　this IEnumerable<T> source,

　　　　Func<T,bool> predicate); 

　　(3)原型说明：在调用操作符All时，系统把输入序列source中的每一个元素作为参数传递给委托predicate，只有输入序列中所有的元素都能使得委托predicate返回值为true，那么All操作符返回true，否者返回false；

　　(4)示例验证：

//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

            Console.WriteLine("调用All操作符：");
            Console.WriteLine("------------------------------------");

bool flag2 = employees.All(e => e.Age <60);

if (flag2)
                Console.WriteLine("没有年龄超过60的雇员！");
else
                Console.WriteLine("有年龄大于等于60的雇员！");

            Console.Read();
        }

结果：

　　16.Contains操作符

　　(1)作用：用于判断输入序列中是否含有指定元素；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static bool Contains<T>(

　　　　this IEnumerable<T> source,

　　　　T value); 

　　　　②原型定义：

　　　　public static bool Contains<T>(

　　　　this IEnumerable<T> source,

　　　　T value,

　　　　IEqulityComparer<T> Comparer); 

　　(3)原型说明：在调用操作符contains时，系统将在输入序列中查找与value相等的元素。若找到则返回true，否者返回false。相比较第一种方法原型，第二种方法多了一个类型为IEqulityComparer<T> 的参数，它能让开发人员自定义相等比较逻辑来对输入序列中的元素和参数value作相等比较。而第一种原型用的是EqulityComparer<T>.Default实现的相等比较；

　　(4)示例验证：

①自定义雇员名字比较类：

//雇员名字比较类
publicclass EmployeeNameComparer:IEqualityComparer<string>
    {
publicbool Equals(string name1, string name2)
        {
return name1 == name2;
        }

publicint GetHashCode(string name)
        {
return name.GetHashCode();
        }
    }

②调用操作符Contains：

staticvoid Main(string[] args)
        {      
//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

//Contains第一个原型
          Console.WriteLine("调用Contains操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

bool flag3 = employees.Select(e => e.Age).Contains(55);
if (flag3)
                Console.WriteLine("序列中含有年龄为55的雇员!");
else
                Console.WriteLine("雇员中没有年龄为55的雇员!");

            Console.WriteLine("***************************************************");

//Contains第二个原型
          Console.WriteLine("调用Contains操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

//生成一个雇员名字比较类的辅助对象
          EmployeeNameComparer enc=new EmployeeNameComparer();

bool flag4 = employees.Select(e => e.Name).Contains("张麻子", enc);
if (flag4)
                Console.WriteLine("雇员中有名为张麻子的！(含有辅助比较对象)");
else
                Console.WriteLine("雇员中没有名为张麻子的！(含有辅助比较对象)");

            Console.Read();
        }

③结果：

　　17.Count操作符

　　(1)作用：用于计算输入序列的元素个数或满足特定条件的元素个数；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static int Count<T>(

　　　　this IEnumerable<T> source); 

　　　　②原型定义：

　　　　public static int Count<T>(

　　　　this IEnumerable<T> source,

　　　   Func<T,bool> predicate); 

　　(3)原型说明：相比于第一种原型方法，第二种多了一个委托参数predicate，在调用操作符Count时，系统将输入序列中的每一个元素作为参数传递给委托predicate，所有使得委托predicate返回值为true的元素的个数被作为返回结果；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

//Count第一个原型
          Console.WriteLine("调用Count操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

int count = employees.Count();

            Console.WriteLine("雇员数为：{0}",count);

            Console.WriteLine("***************************************************");

//Count第二个原型
          Console.WriteLine("调用Count操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

int count1 = employees.Count(e=>e.Age>30);

            Console.WriteLine("年龄大于30的雇员数为：{0}", count1);

            Console.Read();
        }

结果：

　　18.LongCount操作符

　　(1)作用：用于计算输入序列的元素个数或满足特定条件的元素个数；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static long LongCount<T>(

　　　　this IEnumerable<T> source); 

　　　　②原型定义：

　　　　public static long LongCount<T>(

　　　　this IEnumerable<T> source,

　　　   Func<T,bool> predicate); 

　　(3)原型说明：原型定义和实现原理和操作符Count相同，唯一区别在于Count操作符返回值为int类型，LongCount操作符返回值为long类型；

　　(4)示例验证：略；

　　19.Sum操作符

　　(1)作用：用于计算输入序列中所有元素数值总和；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static Numeric Sum(

　　　　this IEnumerable<Numeric > source);

　　　　②原型定义：

　　　　public static Numeric Sum<T>(

　　　　this IEnumerable<T> source,

　　　　Func<T,Numeric> selector);

　　(3)原型说明：要注意的是第一种方法原型的输入序列中的元素类型只能是int、long、double和decimal的等数值类型。而第二种方法就不要求输入序列中的元素一定要为数值型的，其中委托参数selector，就是把输入序列中每一个元素传递给它，委托selector一次返回元素中的数值，再把这些数值求和返回；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员薪水数组
            Salary[] salarys =new Salary[]
            {
new Salary{EmployeeId="0001",Wage=1700,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0004",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0005",Wage=2000,Bonus=4000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0006",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0007",Wage=3000,Bonus=5000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0001",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=4000,SalaryTime=new DateTime(2011,8,15)},
            };

//Sum第一个原型
          Console.WriteLine("调用Sum操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

double wagesum= salarys.Select(s => s.Wage).Sum();

            Console.WriteLine("总共发出工资数：{0}", wagesum);

            Console.WriteLine("***************************************************");

//Sum第二个原型
          Console.WriteLine("调用Sum操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

            var list= salarys.GroupBy(s=>s.EmployeeId).Select(ss=>new {EmployeeId=ss.Key,WageCount=ss.Sum(s=>s.Wage),BounsCount=ss.Sum(s=>s.Bonus)});

            Console.WriteLine("每个雇员发放薪水的总和情况：");
foreach (var s in list)
            {
                Console.WriteLine(s);
            }

            Console.Read();
        }

结果：

　　20.Min操作符

　　(1)作用：用于获取输入序列中所有元素的最小值；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static Numeric Min(

　　　　this IEnumerable<Numeric > source);

　　　　②原型定义：

　　　　public static Numeric Min<T>(

　　　　this IEnumerable<T> source,

　　　　Func<T,Numeric> selector);

　　　　③原型定义：

　　　　public static T Min<T>(

　　　　this IEnumerable<T> source);

　　　　④原型定义：

　　　　public static S Min<T,S>(

　　　　this IEnumerable<T> source,

　　　　Func<T,S> selector);

　　(3)原型说明：同样的，操作符Min的第一种方法原型的输入序列中的元素类型只能是int、long、double和decimal的等数值类型，而第二种方法就不要求输入序列中的元素一定要为数值型的，其中委托参数selector，就是把输入序列中每一个元素传递给它，委托selector一次返回元素中的数值，再从这些数值中返回最小的一个。第三种方法原型允许一个非数值型元素组成的序列中查找最小值，系统将使用IComparable<T>接口或IComparable接口的方法来比较元素大小。最后一种方法原型比第三种原型多了一个委托参数，系统把输入序列source中每一个元素作为参数传递给委托selector，委托selector根据输入参数一次返回类型为S的对象，接着从这些对象中返回最小的一个；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

//定义雇员薪水数组
            Salary[] salarys =new Salary[]
            {
new Salary{EmployeeId="0001",Wage=1700,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0004",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0005",Wage=2000,Bonus=4000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0006",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0007",Wage=3000,Bonus=5000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0001",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=4000,SalaryTime=new DateTime(2011,8,15)},
            };

//Min第一个原型
          Console.WriteLine("调用Min操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

double minwage = salarys.Select(s => s.Wage).Min();

            Console.WriteLine("最低工资：{0}", minwage);

            Console.WriteLine("***************************************************");

//Min第二个原型
          Console.WriteLine("调用Min操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

double minsalarycount = salarys.ToDictionary(s =>new { s.EmployeeId, s.SalaryTime }).Min(s=>s.Value.Bonus+s.Value.Wage);

            Console.WriteLine("薪水的总和最低：{0}",minsalarycount);

            Console.WriteLine("***************************************************");

//Min第三个原型
          Console.WriteLine("调用Min操作符第三个方法原型：");
            Console.WriteLine("------------------------------------");

string employeename = employees.Select(e => e.Name).Min();

            Console.WriteLine("按字符排序的雇员名最小值：{0}",employeename);
 
            Console.WriteLine("***************************************************");

//Min第四个原型
          Console.WriteLine("调用Min操作符第四个方法原型：");
            Console.WriteLine("------------------------------------");

string employeename1 = employees.Min(e => e.Name);

            Console.WriteLine("按字符排序的雇员名最小值：{0}", employeename1);

            Console.Read();
        }

结果：

　　21.Max操作符

　　(1)作用：用于获取输入序列中所有元素的最大值；

　　(2)方法原型：　

　　　　①原型定义：

　　　　public static Numeric Max(

　　　　this IEnumerable<Numeric > source);

　　　　②原型定义：

　　　　public static Numeric Max<T>(

　　　　this IEnumerable<T> source,

　　　　Func<T,Numeric> selector);

　　　　③原型定义：

　　　　public static T Max<T>(

　　　　this IEnumerable<T> source);

　　　　④原型定义：

　　　　public static S Max<T,S>(

　　　　this IEnumerable<T> source,

　　　　Func<T,S> selector);

　　(3)原型说明：四种方法原型和Min操作符一样，实现方法也相同，唯一区别在于Max操作符求最大值，Min操作符求最小值；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员数组
            Employee[] employees =new Employee[]
            {
new Employee{Id="0001",Name="张三",Age=32},
new Employee{Id="0002",Name="李四",Age=31},
new Employee{Id="0003",Name="王五",Age=32},
new Employee{Id="0004",Name="小六",Age=25},
new Employee{Id="0005",Name="张麻子",Age=40},
new Employee{Id="0006",Name="王小二",Age=25}, 
new Employee{Id="0007",Name="灭绝师太",Age=55},
            };

//定义雇员薪水数组
            Salary[] salarys =new Salary[]
            {
new Salary{EmployeeId="0001",Wage=1700,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0004",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0005",Wage=2000,Bonus=4000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0006",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0007",Wage=3000,Bonus=5000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0001",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=4000,SalaryTime=new DateTime(2011,8,15)},
            };

//Max第一个原型
          Console.WriteLine("调用Max操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

double maxwage = salarys.Select(s => s.Wage).Max();

            Console.WriteLine("最高工资：{0}", maxwage);

            Console.WriteLine("***************************************************");

//Max第二个原型
          Console.WriteLine("调用Max操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

double maxsalarycount = salarys.ToDictionary(s =>new { s.EmployeeId, s.SalaryTime }).Max(s => s.Value.Bonus + s.Value.Wage);

            Console.WriteLine("薪水的总和最高：{0}", maxsalarycount);

            Console.WriteLine("***************************************************");

//Max第三个原型
          Console.WriteLine("调用Max操作符第三个方法原型：");
            Console.WriteLine("------------------------------------");

string employeename2 = employees.Select(e => e.Name).Max();

            Console.WriteLine("按字符排序的雇员名最大值：{0}", employeename2);

            Console.WriteLine("***************************************************");

//Max第四个原型
          Console.WriteLine("调用Max操作符第四个方法原型：");
            Console.WriteLine("------------------------------------");

string employeename3 = employees.Max(e => e.Name);

            Console.WriteLine("按字符排序的雇员名最大值：{0}", employeename3);

            Console.Read();
        }

结果：

　　22.Average操作符

　　(1)作用：用于计算输入序列中所有元素的平均值；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static Result Average(

　　　　this IEnumerable<Numeric > source);

　　　　②原型定义：

　　　　public static Result Average<T>(

　　　　this IEnumerable<T> source,

　　　　Func<T,Numeric> selector);

　　(3)原型说明：和Sum操作符一样，第一种方法原型的输入序列中的元素类型只能是int、long、double和decimal的等数值类型。且返回的Result代表一种对应的数值类型，而第二种方法就不要求输入序列中的元素一定要为数值型的，其中委托参数selector，就是把输入序列中每一个元素传递给它，委托selector一次返回元素中的数值，再把这些数值求平均值返回；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员薪水数组
            Salary[] salarys =new Salary[]
            {
new Salary{EmployeeId="0001",Wage=1700,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0004",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0005",Wage=2000,Bonus=4000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0006",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0007",Wage=3000,Bonus=5000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0001",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=4000,SalaryTime=new DateTime(2011,8,15)},
            };

//Average第一个原型
          Console.WriteLine("调用Average操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

double avewage = salarys.Select(s => s.Wage).Average();

            Console.WriteLine("平均工资：{0}", avewage);

            Console.WriteLine("***************************************************");

//Average第二个原型
          Console.WriteLine("调用Average操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

            var list1 = salarys.GroupBy(s => s.EmployeeId).Select(ss =>new { EmployeeId = ss.Key, AveWage = ss.Average(s => s.Wage), AveBonus = ss.Average(s => s.Bonus) });

            Console.WriteLine("每个雇员的平均薪水：");
foreach (var s in list1)
            {
                Console.WriteLine(s);
            }

            Console.Read();
        }

结果：

　　23.Aggregate操作符

　　(1)作用：用于在输入序列的所有元素上累积执行某个特定的方法；

　　(2)方法原型：

　　　　①原型定义：

　　　　public static T Aggregate<T>(

　　　　this IEnumerable<T> source,

　　　　Func<T,T,T> func);

　　　　②原型定义：

　　　　public static U Aggregate<T,U>(

　　　　this IEnumerable<T> source,

　　　　U seed,

　　　　Func<U,T,U> func);

　　(3)原型说明：第一种方法原型中的委托参数func接收两个类型为T的输入参数，返回一个类型为T的结果。当操作符Aggregate被调用时，系统将输入序列中的元素和委托func的上一次执行的结果一起作为委托func的输入参数，委托func根据这两个参数计算出结果，再和下一个输入序列元素一起作为委托func的两个输入参数，就这样依次迭代，直到最后一次调用委托func返回结果。其中要注意的是第一次调用委托func时，只是传递输入序列中的元素一个参数。相比较于第一种方法原型，第二种多了一个参数seed，它主要用于当系统第一次调用委托func时，第二种原型方法把输入序列中的元素和参数seed两个参数传递给委托func。而第一种方法只是传递输入序列的元素一个参数给委托func；

　　(4)示例验证：

staticvoid Main(string[] args)
        {
//定义雇员薪水数组
            Salary[] salarys =new Salary[]
            {
new Salary{EmployeeId="0001",Wage=1700,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=2500,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0004",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0005",Wage=2000,Bonus=4000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0006",Wage=1000,Bonus=2000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0007",Wage=3000,Bonus=5000,SalaryTime=new DateTime(2011,7,15)},
new Salary{EmployeeId="0001",Wage=1700,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0002",Wage=1500,Bonus=3000,SalaryTime=new DateTime(2011,8,15)},
new Salary{EmployeeId="0003",Wage=1700,Bonus=4000,SalaryTime=new DateTime(2011,8,15)},
            };

//Aggregate第一个原型
          Console.WriteLine("调用Aggregate操作符第一个方法原型：");
            Console.WriteLine("------------------------------------");

double bonuscount = salarys.Select(s => s.Bonus).Aggregate((result, next) => result + next);

            Console.WriteLine("发放的总奖金：{0}", bonuscount);

            Console.WriteLine("***************************************************");

//Aggregate第二个原型
          Console.WriteLine("调用Aggregate操作符第二个方法原型：");
            Console.WriteLine("------------------------------------");

double bonuscount1 = salarys.Select(s => s.Bonus).Aggregate(0,(result, next) =>Convert.ToInt32(result + next));//注：委托返回值类型和参数seed的类型要相同

          Console.WriteLine("发放的总奖金：{0}", bonuscount1);

            Console.Read();
        }

结果：