c# linq相关

using System;

using System.Collections.Generic;

using System.Linq;

 namespace LinqTest{

   class Program

    {

 static void Main()

        {

            List<Product>listProduct = new List<Product>{

                    new Product{StockNum=1,ProductNo="01",Tag="a"},

                    new Product{StockNum=2,ProductNo="01",Tag="b"},

                    new Product{StockNum=3,ProductNo="02",Tag="c"},

                    new Product{StockNum=4,ProductNo="02",Tag="d"},

                    new Product{StockNum=5,ProductNo="03",Tag="e"},

                };

 

            //注:处理目标->将"编号(ProductNo)"相同的产品记录，"库存量(StockNum)"合并，"附属标签(Tag)"合并

 

            //合并处理

            listProduct.ForEach(c=> {

                var group = listProduct.Where(a=> a.ProductNo == c.ProductNo);

                c.StockNum= group.Sum(x => x.StockNum);

                c.Tag= group.Select(t => t.Tag).ToList().Join();

            });

 

            //去重复

            listProduct= listProduct.Distinct(new ProductNoComparer()).ToList();

 

            //输出验证

            listProduct.ForEach(c=>

            {

                Console.WriteLine("ProductNo={0},StockNum={1},Tag={2}",c.ProductNo, c.StockNum, c.Tag);

            }); 

         

            //输出结果:

            //ProductNo=01,StockNum=3,Tag=a,b

            //ProductNo=02,StockNum=7,Tag=c,d

            //ProductNo=03,StockNum=5,Tag=e

 

            Console.Read();

        }

 

}

 

    /// <summary>

    ///工具类(一般开发中，可定义在自己的工具类库里)

    /// </summary>

    static class Utils {

 

        ///<summary>

        ///List扩展方法，将List元素用分隔符连接后，返回字符串

        ///</summary>

        ///<typeparam name="T"></typeparam>

        ///<param name="list"></param>

        ///<param name="splitStr"></param>

        ///<returns></returns>

        public static StringJoin<T>(this List<T> list, string splitStr=",")

        {

            string result = string.Empty;

            foreach (var item in list)

            {

                result+= item.ToString() + splitStr;

            }

            return result.Trim(splitStr.ToCharArray());

        }

    }

 

    ///<summary>

    /// 产品实体类

    ///</summary>

    class Product

    {

        ///<summary>

        ///库存

        ///</summary>

        public int StockNum{ set; get; }

         

        ///<summary>

        ///产品编号

        ///</summary>

        public String ProductNo { set; get; }

         

        ///<summary>

        ///附属标签

        ///</summary>

        public String Tag { set; get; }

    }

 

    /// <summary>

    ///去"重复"时候的比较器(只要ProductNo相同，即认为是相同记录)

    ///</summary>

    class ProductNoComparer : IEqualityComparer<Product>

    {

        public bool Equals(Product p1,Product p2)

        {

            if (p1 == null)

                return p2 == null;

            return p1.ProductNo == p2.ProductNo;

        }

 

        public int GetHashCode(Productp)

        {

            if (p == null)

                return 0;

            return p.ProductNo.GetHashCode();

        }

    }

}

 

 

//////// C# 使用Dictionary、linq实现根据集合里面的字符串进行分组

//对下面集合里面的字符串按照“_”进行分组。

List<string>list = new List<string>(){ "1_32", "2_10", "1_8", "1_25", "2_3", "3_5", "5_15", "3_16" };

#region //使用字典，键值对集合保存分组数据。

            Dictionary<string, List<string>> groupDic = new Dictionary<string, List<string>>();

            foreach (var item in list)

            {

                //取KEY值

                string key = item.Split('_')[0];

                //根据key值判断集合中是否存在指定的键，不存在则创建一个。

                if (!groupDic.ContainsKey(key))

                {

                    groupDic.Add(key, new List<string>()); //初始化

                }

                groupDic[key].Add(item); //直接把当前元素添加到，key对应的List集合中。

            }

            foreach (var item in groupDic)

            {

                var s = groupDic[item.Key];

                for (int i = 0; i < s.Count; i++)

                {

                    Console.WriteLine("KEY:{0} Value:{1}", item.Key, s[i]);

                }

            } 

            #endregion

#region //使用linq 分组

            var groupList = from s in list

                            group s by s.Split('_')[0] into g

                            select g;

            foreach (var item in groupList)

            {

                var s = groupDic[item.Key];

                for (int i = 0; i < s.Count; i++)

                {

                    Console.WriteLine("KEY:{0} Value:{1}", item.Key, s[i]);

                }

            } 

            #endregion

#region //使用lambda 分组

            var groupList2 = list.GroupBy(s => s.Split('_')[0]).Select(g => g);

            foreach (var item in groupList2)

            {

                var s = groupDic[item.Key];

                for (int i = 0; i < s.Count; i++)

                {

                    Console.WriteLine("KEY:{0} Value:{1}", item.Key, s[i]);

                }

            }

            #endregion

 

//////////////////////  c# Lamda////////////////////////////

1. 普通绑定：

public void button1_Click(object sender, EventArgs e)

        {

            MessageBox.Show("ok");

        }

this.button1.Click += button1_Click;

2. 匿名委托：

this.button1.Click += delegate(object sender, EventArgs e)

            {

                MessageBox.Show("Click");

            };

3. LAMDA表达式：

this.button1.Click += ((sender, e) =>

            {

                MessageBox.Show("Click");

            });

4. 过滤条件：

List<User> users = new List<User>();

            Func<User, bool> predicate = (

                (user) =>

                {

                    return user.UserId > 100;

                }

                );

            List<User> temps = users.Where(predicate).ToList();

等同于：

List<User> temps = users.Where(p => p.UserId > 100).ToList();

List<User> temps = (from p in users where p.UserId > 100 select p).ToList();

List<User> users = new List<User>();

            Func<User, bool> predicate = (

                (user) => user.UserId > 100

                );

            List<User> temps = users.Where(predicate).ToList();

5. 排序：

List<User> users = new List<User>();

            List<User> temp1 = users.OrderBy(p=>p.UserId).ToList();

            Func<User, int> orderby = (user => user.UserId);

            List<User> temp2 = users.OrderBy(orderby).ToList();

 

/////////////////////c# linq 及 lamda表达式 GroupBy分组////////////////////////////

public partial class Form1 : Form 

   { 

       public Form1() 

       { 

            InitializeComponent(); 

       } 

     

       List<Person> persons1 = new List<Person>(); 

     

       private void Form1_Load(object sender, EventArgs e) 

       { 

            initForm(); 

       } 

       private void initForm() 

       {//窗体初始化 

            persons1.Add(new Person("张三", "男", 20, 1500)); 

            persons1.Add(new Person("王成", "男", 32, 3200)); 

            persons1.Add(new Person("李丽", "女", 19, 1700)); 

            persons1.Add(new Person("何英", "女", 35, 3600)); 

            persons1.Add(new Person("何英", "女", 18, 1600)); 

            dataGridView1.DataSource =persons1;   

       } 

     

       private void button1_Click(object sender, EventArgs e) 

       { 

            //******* 对集合按Name属于进行分组GroupBy查询 ******** 

            //结果中包括的字段： 

            //1、分组的关键字：Name = g.Key 

            //2、每个分组的数量：count = g.Count() 

            //3、每个分组的年龄总和：ageC = g.Sum(item => item.Age) 

            //4、每个分组的收入总和：moneyC = g.Sum(item =>item.Money) 

     

            //写法1：lamda表达式写法（推荐） 

            var ls = persons1.GroupBy(a =>a.Name).Select(g => (new { name = g.Key, count = g.Count(), ageC =g.Sum(item => item.Age), moneyC = g.Sum(item => item.Money) })); 

            //写法2：类SQL语言写法最终编译器会把它转化为lamda表达式 

           var ls2 = from ps inpersons1 

                     group ps by ps.Name 

                         into g 

                         select new { name =g.Key, count = g.Count(), ageC = g.Sum(item => item.Age), moneyC =g.Sum(item => item.Money) }; 

     

            dataGridView1.DataSource =ls.ToList(); 

           //dataGridView1.DataSource =ls2.ToList(); 

       } 

   } 

     

   /// <summary> 

   /// 手动设计一个Person类。用于放到List泛型中 

   /// </summary> 

   public class Person 

   { 

        public string Name { get; set; } 

       public int Age  { get;private set;} 

       public string Sex { get; set; } 

       public int Money { get; set; } 

     

       public Person(string name, string sex, int age, int money) 

       { 

            Name = name; 

            Age = age; 

            Sex = sex; 

            Money = money; 

       } 

}

 

//////////////////////  c# selectlist Distinct() 去重 ////////////////////////////

List<ModelJD> data = myDalJD.GetAllDataList(); 

List<string> list= new List<string>();

list= datalist4.Select(p => p.name).ToList();  //只取name字段，重新生成新的List集合

this.cmbJdUserName.DataSource = list.Distinct().ToList(); //去重复，绑定数据后面要加ToList()

 

//////////////////////  解释linq ////////////////////////////

class Program { 
static void Main(string[] args) { 
IList<string> numbers = new List<string>()  { "One", "Two", "Three", "Four", "Five", "Six", "Seven"  }; 
var numbersLengthThree = numbers.Where(x => x.Length == 3).Select(x=> x).ToList(); 
numbersLengthThree.ForEach(x => Console.WriteLine(x)); 
} } }

上面的代码会产生一个string类型的列表(列表中是数字)存储在List<string>中,上面的程序会找出在这些项中字符总数是3的并且将结果存储到另外一个新的列表中.最后在控制台中打印出这些数字.这个程序输出的结果如下: 

One 

Two 

Six 

让我们做一个研究去找出它是如何工作的.在上面的例子中最重要的代码是numbers.Where(x=> x.Length == 3).Select(x => x).ToList().下边的图表会为我们解释整个的执行过程. 

通过上面的图表我们可以知道CLR伴随着MulticastDelegate实例(持有着关于<Main>b_1方法的信息)将数字列表作为输入参数传递到Where方法,其中<Main>b_1创建于匿名函数(x=>x.Length==3).通过Where方法它会返回一个WhereListIterator<string>迭代器的实例,这个实例将会作为输入参数传递到Select子句中,伴随着另外一个MulticastDelegate实例(持有着关于<Main>b_2方法的信息),<Main>b_2通过匿名方法(x=>x)创建。Select方法将根据输入内容实例化相关的迭代器。在这种情况下，它会实例化出WhereSelectListIterator<string,string>迭代器。这个迭代器将作为输入参数传递到ToList()方法中。此方法最终通过循环遍历对原始列表进行处理并得到一个基于过滤条件的新列表。

 

 

 

 

 

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Collections;

using System.Linq.Expressions;

 

namespace Linq_Learning

{

   //public static class Enumerable

   //{

    //    public static IEnumerable<TSource>Where<TSource>(

   //        thisIEnumerable<TSource> source, Func<TSource, bool> predicate);

   //}

 

   //public static class Queryable

   //{

   //    public staticIQueryable<TSource> Where<TSource>(

   //        thisIQueryable<TSource> source, Expression<Func<TSource, bool>>predicate);

   //}

 

   static class MyEnumerable

    {

       // 自定义扩展方法示例

       public static IEnumerable<TSource> MyWhere<TSource>(

           this IEnumerable<TSource> source, Func<TSource, bool>predicate)

       {

           foreach (TSource item in source)

           {

                if (predicate(item))

                    yield return item;

           }

       }

    }

 

    class Program

    {

       static string Hello(string a, string b)

       {

           return "欢迎光临我的博客" + Environment.NewLine + a + " " + b;

       }

 

       static void Main(string[] args)

       {

 

           #region begion

 

           // 委托函数

           Func<string, string, string> func1 = Hello;

           // 匿名方法

           Func<string, string, string> func2 =

                delegate(string a, string b)

                {

                    return "欢迎光临我的博客"+ Environment.NewLine + a + " " + b;

                };

           // Lambda表达式

           Func<string, string, string> func3 =

                (a, b) => { return "欢迎光临我的博客"+ Environment.NewLine + a + " " + b; };

 

            // 调用Func委托

           string helloStr = func2("滴答的雨",@"http://www.cnblogs.com/heyuquan/");

 

           Console.WriteLine(helloStr);

           Console.WriteLine();

 

           #endregion

 

           #region 延迟计算注意点

 

           //DelayCalculate();

 

           #endregion

 

           #region 过滤操作符（Where，OfType，Distinct）

 

           //Where_Query();

           //Where_Fluent();

           //OfType_Fluent();

 

           #endregion

 

           #region 投影操作符（Select，SelectMany）

 

           //SelectMany_Query();

           //SelectMany_Fluent();

 

           #endregion

 

           #region 排序操作符（Order，OrderByDescending，ThenBy，ThenByDescending，Reverse）

 

           //Order_Query();

           //Order_Fluent();

           //Reverse_Fluent();

 

           #endregion

 

           #region 连接操作符（Join，GroupJoin）

 

           //Join_Query();

           //Join_Fluent();

           //GroupJoin_Query();

           //GroupJoin_Fluent();

 

           #endregion

 

           #region 分组操作符（Group，GroupBy）

 

           //Group_Query();

           //Group_Fluent1();

           //Group_Fluent2();

 

           #endregion

 

           #region 量词操作符（All、Any、Contains）

 

           //Any_Fluent();

 

           #endregion

 

           #region 分区操作符（Skip,Take）

 

           //Paging_Query();

 

           #endregion

 

           #region 集合操作符（Union，Concat，Intersect，Except，Zip，SequenceEqual）

 

           //Intersect_Fluent();

           //Zip_Fluent();

           //SequenceEqual_Fluent();

 

           #endregion

 

           #region 元素操作符（First，FirstOrDefault，Last，LastOrDefault，ElementAt，ElementAtOrDefault，Single，SingleOrDefault）

 

           //ElementAt_Fluent();

 

           #endregion

 

           #region 合计操作符（Count、LongCount、Sum、Max、Min、Average、Aggregate）

 

           //Sum_Fluent();

           //Aggregate_Fluent();

 

           #endregion

 

           #region 转换操作符（Cast，ToArray，ToList，ToDictionary，ToLookup，AsEnumerable，DefaultIfEmpty）

 

           //Lookup_Fluent();

           //DefaultIfEmpty_Fluent();

 

           #endregion

 

           #region 生成操作符（Range，Empty，Repeat）

 

           //Range_Fluent();

 

           #endregion

 

           Console.Read();

       }

 

       #region 延迟计算注意点

 

       private static void DelayCalculate()

       {

           IEnumerable<char> query = "Not what you might expect";

           foreach (char item in "aeiou")

                query = query.Where(c => c!= item);

           // 只删除了'u'----Not what yo might expect 

           foreach (char c in query)

                Console.Write(c);

 

           // 因为item变量是循环外部声明的，同一个变量重复声明更新,

           // 所以每个lambda表达式获取的是同样的item.之后枚举查询时，

           // 所有的lambda表达式引用了这个变量的当前值,即'u'。          

           Console.WriteLine();

           // 为了解决这个问题，必须将循环变量赋值到一个在循环代码块内声明的变量

 

           IEnumerable<char> query1 = "Not what you might expect";

           foreach (char item in "aeiou")

           {

                char temp = item;

                query1 = query1.Where(c => c!= temp);

           }

           // Nt wht y mght xpct 

           foreach (char c in query1)

                Console.Write(c);

       }

 

       #endregion

 

       #region 过滤操作符（Where，OfType，Distinct）

       /// <summary>

       /// 查询获得车手冠军次数大于15次且是Austria国家的一级方程式赛手

       /// </summary>

       private static void Where_Query()

       {

           Console.WriteLine();

           Console.WriteLine("过滤操作符：where示例（查询表达式）");

 

           var racer = from r in Formula1.GetChampions()

                        where r.Wins > 15&& r.Country == "Austria"

                        select r;

           foreach (var item in racer)

           {

               Console.WriteLine("{0:A}", item);

           }

       }

 

       /// <summary>

       /// 查询获得车手冠军次数大于15次且是Austria国家的一级方程式赛手

       /// </summary>

       private static void Where_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("过滤操作符：where示例（方法语法）");

 

           var racer = Formula1.GetChampions().Where(r => r.Wins > 15

                && r.Country =="Austria");

 

           foreach (var item in racer)

           {

               Console.WriteLine("{0:A}", item);

           }

       }

 

       /// <summary>

       /// 过滤object数组中的元素，返回字符串类型的数组

       /// </summary>

       private static void OfType_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("过滤操作符：OfType()示例");

 

           object[] data = { "one", 2, 3, "four","five", 6 };

           var query = data.OfType<string>();

           foreach (var item in query)

           {

                Console.WriteLine(item);

           }

       }

       #endregion

 

       #region 投影操作符（Select，SelectMany）

 

       /// <summary>

       /// （Racer类定义了一个属性Cars，Cars是一个字符串数组。）过滤驾驶Ferrari的所有冠军

       /// </summary>

       private static void SelectMany_Query()

       {

           Console.WriteLine();

           Console.WriteLine("投影操作符：SelectMany示例（查询表达式）");

 

           var ferrariDrivers = from r in Formula1.GetChampions()

                                 from c inr.Cars

                                 where c =="Ferrari"

                                 orderbyr.LastName

                                 selectr.FirstName + " " + r.LastName;

           foreach (var item in ferrariDrivers)

           {

                Console.WriteLine(item);

           }

       }

 

       /// <summary>

       /// （Racer类定义了一个属性Cars，Cars是一个字符串数组。）过滤驾驶Ferrari的所有冠军

       /// </summary>

       private static void SelectMany_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("投影操作符：SelectMany示例（方法语法）");

           var ferrariDrivers = Formula1.GetChampions()

                .SelectMany(

                    r => r.Cars,

                    (r, c) => new { Racer =r, Car = c }

                )

                .Where(r => r.Car =="Ferrari")

                .OrderBy(r =>r.Racer.LastName)

                .Select(r =>r.Racer.FirstName + " " + r.Racer.LastName);

           foreach (var item in ferrariDrivers)

           {

                Console.WriteLine(item);

           }

       }

 

       #endregion

 

       #region 排序操作符（Order，OrderByDescending，ThenBy，ThenByDescending，Reverse）

 

       private static void Order_Query()

       {

           Console.WriteLine();

           Console.WriteLine("排序操作符：排序操作符示例（查询表达式）");

           var racers = from r in Formula1.GetChampions()

                         orderby r.Country,r.LastName descending, r.FirstName

                         select r;

           foreach (var item in racers)

           {

                Console.WriteLine(item);

           }

       }

 

       private static void Order_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("排序操作符：排序操作符 ectMany示例（方法语法）");

           var racers = Formula1.GetChampions()

                .OrderBy(r => r.Country)

                .ThenByDescending(r => r.LastName)

                .ThenBy(r => r.FirstName);

           foreach (var item in racers)

           {

                Console.WriteLine(item);

           }

       }

 

       private static void Reverse_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("排序操作符：Reverse 示例（方法语法）");

           var racers = Formula1.GetChampions()

                .OrderBy(r => r.Country)

                .Reverse();

           foreach (var item in racers)

           {

                Console.WriteLine(item);

           }

       }

 

       #endregion

 

       #region 连接操作符（Join，GroupJoin）

 

       /// <summary>

       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联

       /// </summary>

       private static void Join_Query()

       {

           Console.WriteLine();

           Console.WriteLine("连接操作符：Join 示例（查询表达式）");

           var racers = from r in Formula1.GetChampions()

                         from y in r.Years

                         where y > 1958&& y < 1965

                         select new

                         {

                             Year = y,

                             Name = r.FirstName+ " " + r.LastName

                         };

 

           var teams = from t inFormula1.GetContructorChampions()

                        from y in t.Years

                        where y > 1958&& y < 1965

                        select new { Year = y,Name = t.Name };

 

           var racersAndTeams = from r in racers

                                 join t inteams on r.Year equals t.Year

                                 select new

                                 {

                                     Year =r.Year,

                                     Racer =r.Name,

                                     Team =t.Name

                                 };

           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军");

           foreach (var item in racersAndTeams)

           {

                Console.WriteLine("{0}\t\t{1}\t\t{2}"

                    , item.Year, item.Racer,item.Team);

           }

       }

 

       /// <summary>

       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联

       /// </summary>

       private static void Join_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("连接操作符：Join 示例（方法语法）");

           var racers = Formula1.GetChampions()

                .SelectMany(y => y.Years,(r, y)

                    => new { Year = y, Name= r.FirstName + " " + r.LastName })

                .Where(ty => ty.Year >1958 && ty.Year < 1965);

 

           var teams = Formula1.GetContructorChampions()

                .SelectMany(y => y.Years,(t, y) => new { Year = y, Name = t.Name })

                .Where(ty => ty.Year > 1958&& ty.Year < 1965);

 

           var racersAndTeams = racers.Join(teams

                    , r => r.Year, t =>t.Year

                    , (r, t) => new { Year =r.Year, Racer = r.Name, Team = t.Name }

                );

 

           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军");

           foreach (var item in racersAndTeams)

           {

               Console.WriteLine("{0}\t\t{1}\t\t{2}"

                    , item.Year, item.Racer,item.Team);

           }

       }

 

       /// <summary>

       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联并分组

       /// </summary>

       private static void GroupJoin_Query()

       {

           Console.WriteLine();

           Console.WriteLine("连接操作符：GroupJoin 示例（查询表达式）");

           var racers = from r in Formula1.GetChampions()

                         from y in r.Years

                         where y > 1958&& y < 1965

                         select new

                         {

                             Year = y,

                             Name = r.FirstName+ " " + r.LastName

                         };

 

           var teams = from t in Formula1.GetContructorChampions()

                        from y in t.Years

                        where y > 1958&& y < 1965

                        select new { Year = y,Name = t.Name };

 

           var racersAndTeams = from r in racers

                                 join t inteams on r.Year equals t.Year

                                 intogroupTeams

                                 select new

                                {

                                     Year =r.Year,

                                     Racer =r.Name,

                                     GroupTeams= groupTeams

                                 };

           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军数");

           foreach (var item in racersAndTeams)

           {

               Console.WriteLine("{0}\t\t{1}\t\t{2}"

                    , item.Year, item.Racer,item.GroupTeams.Count());

           }

       }

 

       /// <summary>

       /// 返回1958到1965年间的车手冠军和车队冠军信息，根据年份关联并分组

       /// </summary>

       private static void GroupJoin_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("连接操作符：GroupJoin 示例（方法语法）");

            var racers = Formula1.GetChampions()

                .SelectMany(y => y.Years,(r, y)

                    => new { Year = y, Name= r.FirstName + " " + r.LastName })

                .Where(ty => ty.Year >1958 && ty.Year < 1965);

 

           var teams = Formula1.GetContructorChampions()

                .SelectMany(y => y.Years,(t, y) => new { Year = y, Name = t.Name })

                .Where(ty => ty.Year >1958 && ty.Year < 1965);

 

           var racersAndTeams = racers

                .GroupJoin(teams

                    , r => r.Year, t =>t.Year

                    , (r, t) => new { Year =r.Year, Racer = r.Name, GroupTeams = t }

                );

 

           Console.WriteLine("年份\t\t车手冠军\t\t车队冠军数");

           foreach (var item in racersAndTeams)

           {

               Console.WriteLine("{0}\t\t{1}\t\t{2}"

                    , item.Year, item.Racer,item.GroupTeams.Count());

           }

       }

 

       #endregion

 

       #region 分组操作符（Group，GroupBy）

 

       /// <summary>

       /// 按城市分组，获取每个城市的车手冠军

       /// </summary>

       private static void Group_Query()

       {

           Console.WriteLine();

           Console.WriteLine("分组操作符：Group 示例（查询表达式）");

           var countries = from r in Formula1.GetChampions()

                            group r byr.Country into g

                            select new {Country = g.Key, Racers = g };

 

           Console.WriteLine("城市\t\t车手冠军数");

           foreach (var item in countries)

           {

               Console.WriteLine("{0}\t\t{1}", item.Country,item.Racers.Count());

           }

       }

 

       /// <summary>

       /// 按城市分组，获取每个城市的车手冠军

       /// </summary>

       private static void Group_Fluent1()

       {

           Console.WriteLine();

           Console.WriteLine("分组操作符：Group 示例1（方法语法）");

           var countries = Formula1.GetChampions()

                .GroupBy(r => r.Country)

                .Select(g => new { Country =g.Key, Racer = g });

 

           Console.WriteLine("城市\t\t车手冠军数");

           foreach (var item in countries)

           {

               Console.WriteLine("{0}\t\t{1}", item.Country,item.Racer.Count());

           }

       }

 

       /// <summary>

       /// 按城市分组，获取每个城市的车手冠军

       /// </summary>

       private static void Group_Fluent2()

       {

           Console.WriteLine();

           Console.WriteLine("分组操作符：Group 示例2（方法语法）");

           var countries = Formula1.GetChampions()

                 .GroupBy(r => r.Country,(k, g) => new { Country = k, Racer = g });

 

           Console.WriteLine("城市\t\t车手冠军数");

           foreach (var item in countries)

           {

               Console.WriteLine("{0}\t\t{1}", item.Country, item.Racer.Count());

           }

       }

 

       #endregion

 

       #region 量词操作符（All、Any、Contains）

 

       /// <summary>

       /// 获取是否存在姓为“Schumacher”的车手冠军

       /// </summary>

       private static void Any_Fluent()

       {

           Console.WriteLine();

           Console.WriteLine("量词操作符：All 示例（方法语法）");

           var hasRacer_Schumacher = Formula1.GetChampions()

                .Any(r => r.LastName =="Schumacher");

           Console.WriteLine("是否存在姓为“Schumacher”的车手冠军？{0}", hasRacer_Schumacher ? "是" :"否");

       }

 

       #endregion

 

       #region 分区操作符（Skip,Take）

 

       // 扩展方法Take()和Skip()操作添加到查询的最后可用于分页

 

       /// <summary>

       /// 将车手冠军列表按每页5个名字进行分页

       /// </summary>

       private static void Paging_Query()

       {

           int pageSize = 5;

 

           int numberPages = (int)Math.Ceiling(

                Formula1.GetChampions().Count()/ (double)pageSize);

 

           for (int page = 0; page < numberPages; page++)

           {

                Console.WriteLine("Page{0}", page);

 

                var racers = (

                              from r inFormula1.GetChampions()

                              orderbyr.LastName

                              selectr.FirstName + " " + r.LastName

                             )

                              .Skip(page *pageSize).Take(pageSize);

 

                foreach (var name in racers)

                {

                    Console.WriteLine(name);

                }

                Console.WriteLine();

           }

       }

 

       #endregion

 

       #region 集合操作符（Union，Concat，Intersect，Except，Zip，SequenceEqual）

 

       /// <summary>

       /// 获取使用车型”Ferrari”和车型”Mclaren”都获得过车手冠军车手列表

       /// </summary>

       private static void Intersect_Fluent()

       {

           Func<string, IEnumerable<Racer>> racersByCar =

                Car => from r inFormula1.GetChampions()

                       from c in r.Cars

                       where c == Car

                       orderby r.LastName

                       select r;

 

           foreach (var racer in racersByCar("Ferrari")

               .Intersect(racersByCar("McLaren")))

           {

                Console.WriteLine(racer);

           }

       }

 

       /// <summary>

       /// 合并html开始标签和结束标签

       /// </summary>

       private static void Zip_Fluent()

       {

           string[] start = { "<html>", "<head>","<body>" };

           string[] end = { "</html>", "</head>","</body>" };

 

           var tags = start.Zip(end, (s, e) => { return s + e; });

 

           foreach (string item in tags)

           {

                Console.WriteLine(item);

           }

       }

 

       /// <summary>

       /// 判断两个序列是否相等，需要内容及顺序都相等

       /// </summary>

       private static void SequenceEqual_Fluent()

       {

           int[] arr1 = { 1, 4, 7, 9 };

           int[] arr2 = { 1, 7, 9, 4 };

           Console.WriteLine("排序前是否相等：{0}"

                , arr1.SequenceEqual(arr2) ?"是" : "否");  // 否

           Console.WriteLine();

           Console.WriteLine("排序后是否相等：{0}"

                ,arr1.SequenceEqual(arr2.OrderBy(k => k)) ? "是" :"否"); // 是

       }

 

       #endregion

 

       #region 元素操作符（First，FirstOrDefault，Last，LastOrDefault，ElementAt，ElementAtOrDefault，Single，SingleOrDefault）

 

       /// <summary>

       /// 获取冠军数排名第三的车手冠军

       /// </summary>

       private static void ElementAt_Fluent()

       {

           var Racer3 =Formula1.GetChampions()

                .OrderByDescending(r =>r.Wins)

                .ElementAtOrDefault(2);

           Console.WriteLine("获取冠军数排名第三的车手冠军为：{0} {1},获奖次数：{2}"

                , Racer3.LastName,Racer3.FirstName, Racer3.Wins);

       }

 

       #endregion

 

       #region 合计操作符（Count、LongCount、Sum、Max、Min、Average、Aggregate）

 

       private static void Sum_Fluent()

       {

           var racerCount = Formula1.GetChampions().Count();

       }

 

       private static void Aggregate_Fluent()

       {

           int[] numbers = { 1, 2, 3 };

           // 1+2+3 = 6

           int y = numbers.Aggregate((prod, n) => prod + n);

           // 0+1+2+3 = 6

           int x = numbers.Aggregate(0, (prod, n) => prod + n);

           // （0+1+2+3）*2 = 12

           int z = numbers.Aggregate(0, (prod, n) => prod + n, r => r * 2);

       }

 

       #endregion

 

       #region 转换操作符（Cast，ToArray，ToList，ToDictionary，ToLookup，AsEnumerable，DefaultIfEmpty）

 

       /// <summary>

       /// 将车手冠军按其使用车型进行分组，并显示使用”williams”车型的车手名字。

       /// </summary>

       private static void Lookup_Fluent()

       {

           ILookup<string, Racer> racers =

                (from r inFormula1.GetChampions()

                 from c in r.Cars

                 select new

                 {

                     Car = c,

                     Racer = r

                 }

                 ).ToLookup(cr => cr.Car, cr=> cr.Racer);

 

           if (racers.Contains("Williams"))

           {

               foreach (varwilliamsRacer in racers["Williams"])

                {

                   Console.WriteLine(williamsRacer);

                }

           }

       }

 

       private static void DefaultIfEmpty_Fluent()

       {

           var defaultArrCount = (new int[0]).DefaultIfEmpty().Count(); // 1

           Console.WriteLine("空int数组的DefaultIfEmpty返回的集合元素个数为:{0}", defaultArrCount);

       }

 

       #endregion

 

       #region 生成操作符（Range，Empty，Repeat）

 

       // 生成操作符 Range()，Empty()，Repeat() 不是扩展方法，而是返回序列的正常静态方法。

 

       private static void Range_Fluent()

       {

           var values = Enumerable.Range(1, 20);

           foreach (var item in values)

           {

                Console.Write("{0} ",item);

            }

           Console.WriteLine();

       }

 

       #endregion

 

    }

}

 

 

///ElementAt 在序列(集合)中,这个方法返回一个特定索引的一个元素

IList<string> numbers = new List<string>() 

{ 

"One","Two","Three" 

}; 

var elementAt = numbers.ElementAt(1); 

Console.WriteLine(elementAt); 

////Empty返回一个指定类型参数的空Ienumerable<T>

var emptyList = Enumerable.Empty<int>(); 

Console.WriteLine(emptyList.Count()); 

////Except方法可以用在从一个集合中删除一个项集合.它放回一个由两个序列产生的集合///差.比如,我有个由{1,2,3,4,5,6,7}组成的集合A和由{1,2,3}组成的集合B,A 除了////(except) B 将会输出{4,5,6,7}

IList<int> firstNumbers = new List<int>() 

{ 

1,2,3,4,5,6,7 

}; 

IList<int> secondNumbers = new List<int>() 

{ 

1,2,3 

}; 

var result = firstNumbers.Except(secondNumbers).ToList(); 

result.ForEach(x => Console.WriteLine(x)); 

///First 返回序列的第一个元素

IList<int> numbers = new List<int>() 

{ 

1,2,3,4,5,6,7 

}; 

var firstItem = numbers.First(); 

var firstItemBasedOnConditions = numbers.First(item => item > 3); 

///FirstOrDefault它返回序列中第一个元素或者当没有元素未被找到时放回默认值.这个方法是///First和Default的综合

/////Union 这个方法将会Union(并集)两个序列(集合).例如,我们有两个集合,A={1,2,3,4,5,6,7}和////B={5,6,7,8,9},并集A和B则返回{1,2,3,4,5,6,7,8,9}.在.NET中,它将连接两个列表(集合)并生成////一个新列表(集合). 

IList<int> firstList = new List<int>()  

{  

1,2,3,4 

}; 

IList<int> secondList = new List<int>()  

{  

7,9,3,4,5,6,7 

}; 

var result = firstList.Union(secondList); 

result.ToList().ForEach(x => Console.WriteLine(x)); 

////Intersect 它将产生两个序列的交集

IList<int> listA = new List<int>() { 1, 2, 3, 4, 5 }; 

IList<int> listB = new List<int>() { 4, 5 }; 

var intersectResult = listA.Intersect(listB);

intersectResult.ToList().ForEach(x => Console.Write("{0}\t",x));