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={1,2,3,4};
IEnumerable<int> query = from da in data where da > 2 select da;

那方法语法呢 如代码：

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

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 = { 1,2,3,4,5,6};
            IEnumerable<int> query = numbers.Select(o => o).Where(o => o > 3);
            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 = { 1,2,3,4,5};
            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 > 0).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入门教程之各种标准查询操作符（二）

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