LINQ入门教程之各种标准查询操作符（一）

好久之前就想系统的学习下LINQ,好久之前……

本篇文章主要介绍LINQ等的标准查询操作符，内容取自《LINQ高级编程》，后续还会介绍LINQ to XML ,LINQ to SQL。

LINQ入门教程之各种标准查询操作符（一）

LINQ入门教程之各种标准查询操作符（二）

进入正题

（一）先介绍下标准查询操作符的概念

它是一系列方法的集合，如常见的Select 、Where、OrderBy等，这些方法作用于序列(集合)之上，序列是一个实现了IEnumerable<T>接口或IQueryable<T>接口的类型的对象。

IEnumerable和IQueryable的一个区别是:IEnumerable接口提供了向前遍历的功能。它不具备在各个数据项之间移动（向前移动除外）的能力。IQueryalbe可以使查询操作更具灵活性。

通俗的讲查询操作符是用好linq的基本，就像砍材要用的刀一样……

（二）另外再说下 查询语法和方法语法的概念

查询语法 即用查询表达式来编写查询。 如代码：

 int[] data={,,,};
 IEnumerable<int> query = from da in data where da >  select da;

那方法语法呢 如代码：

 int[] data={,,,};
 IEnumerable<int> query2 = data.Select(o => o).Where(d => d > );

LINQ在编译的时候，查询语法将会转为方法语法。相对而言，查询语法更容易阅读、理解和维护

（三）各种查询操作符汇总列表

标准查询操作符 (方法语法)	查询表达式（查询语法）
All(Of T)	N/A
Any	N/A
Average	N/A
Cast(Of T)	An explicit range of variables
Count	N/A
Distinct	N/A
GroupBy	group by
GroupJoin	join…in…on…into
Join	join…in…on…equals…
LongCount	N/A
Max	N/A
Min	N/A
OrderBy	order by
OrderByDescending	order by descending
Select	select
SelectMany	Multiple from clauses
Skip	N/A
SkipWhile	N/A
Sum	N/A
Take	N/A
TakeWhile	N/A
ThenBy	order by
ThenByDescending	order by descending
Where	where

备注：N/A (Not Applicable 不适用的)

(四) 下面主要通过代码来讲解各个标准查询操作符。

1．  投影操作符 (Select  SelectMany)

   #region  投影操作符 将序列中的元素转换为一个由开发人员定义的形式的操作
        /// <summary>
        /// 对单个序列或集合中的值进行投影
        /// </summary>
         static void SelectFunction()
         {
             DataContext contexts = new DataContext("Initial Catalog=AdventureWorks; Integrated Security=true");
             Table<Contact> contacts = contexts.GetTable<Contact>();
             //查询语法
             var query = from c in contacts where c.FirstName  == "gong"  select new { c.FirstName };
             //方法语法
             query = contacts.Select(o => new { o.FirstName }).Where(c => c.FirstName == "gong");
             foreach (var item in query)
             {
                 Console.WriteLine(item.FirstName);
             }
         }
         //output:
         //Gong
         //Gong
         class name{ public List<string> pets; public string FirstName;}
         /// <summary>
         /// selectMany 提供了将多个from子句组合起来的功能，它将每个对象的结果合并成单个序列
         /// </summary>
         static void SelectManyFunction( )
         {
           //List<name> list =new List<name>() {
           name[] list =new name[] {
               new name{ FirstName="Gwt",pets=new List<string>{"TEST"} }  ,
               new name{ FirstName="Gwt1",pets=new List<string>{"TEST4","Test41"} },
           };
           //将所有List<string> 合并
             IEnumerable<string> query = list.SelectMany(own => own.pets);
           foreach (string item in query)
           {
               Console.Write(item +" ");
           }
           Console.WriteLine("");
           //下面这个循环等于上面的seletmany方法
             var query2 = list.Select(own => own.pets);
           foreach (var item in query2)
           {
               foreach (var item2 in item)
               {
                   Console.Write(item2+" ");
               }
           }
         }
         //output:
         // TEST TEST4 TEST41
         // TEST TEST4 TEST41

2．  限制操作符 (Where)

     #region  限制操作符
         /// <summary>
         /// where操作符不启动查询的执行，当开始对对象进行枚举时查询才开始执行
         /// </summary>
         static void WhereFunction()
         {
             int[] numbers = { ,,,,,};
             IEnumerable<int> query = numbers.Select(o => o).Where(o => o > );
             foreach (int item in query)
             {
                 Console.Write(item+" ");
             }
         }
         //output;
         //4 5 6
         #endregion

3．  排序操作符 (OrderBy OrderByDescending ThenBy ThenByDescending Reverse)

      #region  排序操作符
         /// <summary>
         /// OrderBy/OrderByDescending     对应提供了按照升序/降序的方式对结果进行排序的功能
         /// ThenBy/ThenByDescending        实现按照次关键字对序列进行升序/降序排列
         /// </summary>
         static void OrderByFunction()
         {
             DataContext context = new DataContext(StaticData.ConnectSql);
             Table<Contact> contacts = context.GetTable<Contact>( );
             IEnumerable<Contact> query = contacts.Select(o => o).OrderBy(o => o.FirstName).ThenBy(o => o.LastName);

             foreach (Contact item in query)
             {
                 Console.WriteLine(item.FirstName + " " + item.LastName);
             }
             Console.WriteLine();
             query = contacts.Select(o => o).OrderByDescending(o => o.FirstName).ThenByDescending(o => o.LastName);
             foreach (Contact item in query)
             {
                 Console.WriteLine(item.FirstName + " " + item.LastName);
             }
         }
         //output:
         //Gong tao
         //Gong taos
         //gong2 tao2
         //gong3 tao3
         //gong4 tao4
         //gong5 tao5
         //
         //gong5 tao5
         //gong4 tao4
         //gong3 tao3
         //gong2 tao2
         //Gong taos
         //Gong tao
         /// <summary>
         /// Reverse 把数据源的数据按相反的顺序返回
         /// </summary>
         static void ReverseFunction()
         {
             int[] numbers = { ,,,,};
             IEnumerable<int> query = numbers.Reverse();
             foreach (int item in query)
             {
                 Console.Write(item+"  ");
             }
         }
         //output:
         //5 4 3 2 1
         #endregion 

4．  联接操作符 (Join GroupJoin)

   #region  联接操作符
         /// <summary>
         /// join 相当于T-SQL中的inner join
         /// </summary>
         static void JoinFunction()
         {
             DataContext context = new DataContext(StaticData.ConnectSql);
             Table<Contact> contact = context.GetTable<Contact>();
             Table<Employee> employee = context.GetTable<Employee>();
             //方法语法
             var query = contact.Join(employee, con => con.ContactID, emp => emp.ContactID,
                 (con, emp) => new { ContactName = con.FirstName, emp })
                 .Where(con=>con.ContactName=="gong2");
             //查询语法
             query = from con in contact
                     join emp in employee on con.ContactID equals emp.ContactID
                     where con.FirstName=="gong2"
                      select new { ContactName = con.FirstName, emp } ;
             foreach (var item in query)
             {
                 Console.WriteLine(item.ContactName + "  " + item.emp.EmployeeID);
             }
         }
         //output:
         //gong2  23
         //gong2  24
         //gong2  25
         //gong2  26
         class Team
         {
             public string TeamName;
         }
         class Rider
         {
             public string Name;
             public string TeamName;
         }
         /// <summary>
         /// GroupJoin
         /// </summary>
         static void GroupJoinFunction()
         {
             List<Team> teams = new List<Team>{new Team{ TeamName="t1"}
             ,new Team{TeamName="t2"}
            ,new Team{TeamName="t3"}
            };
             List<Rider> riders = new List<Rider> {
             new Rider{Name="r1",TeamName="t1"},
             new Rider{Name="r2",TeamName="t1"},
             new Rider{Name="r3",TeamName="t2"},
             new Rider{Name="r4",TeamName="t2"},
             new Rider{Name="r5",TeamName="t3"},
             new Rider{Name="r6",TeamName="t3"},
             };
             //方法语法
             var query = teams.GroupJoin(riders, t => t.TeamName, r => r.TeamName,
                 (t, r) => new { teamname = t.TeamName, ridernames = r.Select(o => o.Name) });
             foreach (var item in query)
             {
                 Console.WriteLine(item.teamname);
                 foreach (var item2 in item.ridernames)
                 {
                     Console.WriteLine("     "+item2);
                 }
             }
         }
         //output:
         //t1
         //    r1
         //    r2
         //t2
         //    r3
         //    r4
         //t3
         //    r5
         //    r6
         #endregion 

5．  分组操作符 (GroupBy)

 #region  分组操作符  根据一个特定的值(选择器) 将序列中的值或元素进行分组
         /// <summary>
         ///
         /// </summary>
         static void GroupByFunction()
         {
             DataContext context = new DataContext(StaticData.ConnectSql);
             Table<SalesOrderHeader> orders = context.GetTable<SalesOrderHeader>();
             //按照每个销售人员对订单进行分组
             var query = orders.Where(o => o.SalesPersonID > ).GroupBy(order => order.SalesPersonID, order => order.CustomerID);

             foreach (var item in query)
             {
                 Console.WriteLine(item.Key);
                 foreach (var item2 in item)
                 {
                     Console.WriteLine("  " + item2);
                 }
             }
         }
         #endregion

6．  串联操作符 (Concat)

  #region  串联操作符
         /// <summary>
         /// 串联操作符 Concat 【将两个集合合并成一个集合】
         /// </summary>
         static void ConcatFunction( )
         {
             DataContext context = new DataContext(StaticData.ConnectSql);
             Table<Contact> contacts = context.GetTable<Contact>( );
             Table<SalesOrderHeader> orders = context.GetTable<SalesOrderHeader>();
             //将Contact表的Firstname和SalesOrderHeader的CustomerID串联起来
             var query = contacts.Select(con => con.FirstName).Concat(orders.Select(order => order.CustomerID.ToString()));
             foreach (var item in query)
             {
                 Console.WriteLine(item.ToString());
             }
           }
         #endregion

LINQ入门教程之各种标准查询操作符（二）

动动您的手指，点下支持，您的支持是我最大动力！