linq总结系列（一）---基础部分

一、linq的基本概念

　　LINQ是C＃和VB中的统一查询语法，使用对象来保存和检索来自不同来源（如数据库、xml、对象集合）的数据。

　　主要功能：消除了编程语言和数据库之间的不匹配，以及为不同类型的数据源提供统一的查询接口。

　　适用范围：LInq适用于实现了IEnumerable <T>（IQueryable继承于IEnumerable ）的实例，如：List，Dictionary，Queue，LinkedList，Array等

二、linq的使用

　　有两种方法可以将LINQ查询写入IEnumerable集合或IQueryable数据源。

　　1、查询语法

　　　　特点：以from子句开头，可以以select或groupBy子句结束

　　2、lambda表达式（简洁且功能更多，推荐）

　　下边给出了简单的例子，注：后边的部分都是使用的这个测试数据。

  //准备的测试数据
            IList<UserInfo> userList = new List<UserInfo>() { 
                 new UserInfo() { UId = 1, UserName = "zs", Age = 23 ,RoleId=1} ,
                 new UserInfo() { UId = 2, UserName = "ls", Age = 20 ,RoleId=2},
                 new UserInfo() { UId = 3, UserName = "ww", Age = 33 ,RoleId=1},
                 new UserInfo() { UId = 4, UserName = "zl", Age = 26 ,RoleId=2},
                 new UserInfo() { UId = 5, UserName = "tq", Age = 42 ,RoleId=2} 
              };//用户列表
            IList<RoleInfo> roleList = new List<RoleInfo>(){
                new RoleInfo(){Rid=1,RoleName="管理员"},
                new RoleInfo(){Rid=2,RoleName="普通用户"},
            };//角色列表

            //query语法
            var resUsers = from u in userList
                           where u.Age > 20
                           select new {u.UId,u.UserName,u.Age};
            //lambda
            var resUsers2 = userList.Where<UserInfo>(u => u.Age > 20).Select
　　　　　　　　　　　　　　　　　　(u => new { u.UId,u.UserName,u.Age});

三、linq详解

1、过滤 (where 和 oftype)

　　Where：根据给定的条件表达式过滤集合，并返回一个新集合

　　OfType：根据类型进行过滤

 　　　　　　IList<object> list = new List<object>() { 1, "hello", user };//user是一个UserInfo的实例
            //query语法
            　　var result = from o in list.OfType<string>()
                         　　select o;
            //lambda语法
           　　 var result2 = list.OfType<string>();

2、排序（OrderBy,OrderByDescending,ThenBy,ThenByDescending）

　　　　//对userList先按Id排序，再按Age排序
            //query语法
            var result = from u in userList
                         orderby u.Id,u.Age descending
                         select u;
            //lambda语法  
            var result2 = userList.OrderByDescending(u => u.Id).ThenBy(u=>u.Age);

3、分组（group by，ToLookUp）

  　　   //query语法
              var resGroups = from u in userList
                              group u by u.RoleId;
         //lambda方式  注：GroupBy延迟执行，而ToLookup是立即执行的，使用方法和GroupBy一样。
              var resGroups2 = userList.GroupBy(u => u.RoleId);
              //遍历(group.Key为设置分组的列的值)
             foreach (var group in resGroups)
              {
                  Console.WriteLine("roleId:{0}", group.Key);
                 foreach (UserInfo user in group)
                 {
                    Console.WriteLine("UserName:{0}", user.UserName);
                 }
             }
             /*结果:  roleId:1
                     UserName:zs
                     UserName:ww
                     roleId:2
                     UserName:ls
           UserName:zl 21  UserName:tq */
    
//多列分组
    var productGroup=
        from p in db.Products
        group p by new
        {
            p.PName,
            p.PColor
        }
        into g
        select new
                {
                    g.Key,//这里的key是一个对象，有两个属性:PName,PColor
                    g
                };
 

4、连接查询（join）

  　//query语法，查询用户名和该用户所属的角色 inner join
             var resJoin = from user in userList
                           join role in roleList
                          on user.RoleId equals role.Rid
                          select new
                           {
                               uname=user.UserName,
                              rname=role.RoleName
                           };
　
    //left join,right join调整下顺序即可
    var resJoin = from user in userList
                          join role in roleList
                          on user.RoleId equals role.Rid into temp
　　              from tt in temp.DefaultIfEmpty
                           select new
                          {
                              uname=user.UserName,
                              rname=role?.RoleName
                           };
    //cross join
    var resJoin = from user in userList
                        from role in roleList
                               select new
                              {
                                  uname=user?.UserName,
                                  rname=role?.RoleName
                              };

         //lambda方式
             var resJoin2 = userList.Join(roleList, 
                 user => user.RoleId,  //outkey
                 role => role.Rid,     //innerkey
                 (user, role) => new   //result
                 {
                     uname = user.UserName,
                     rname = role.RoleName
                 });
             //遍历
             foreach (var item in resJoin2)
             {
                 Console.WriteLine("用户:{0}----角色：{1}", item.uname, item.rname);
             }
 
             /*结果:  用户:zs----角色：管理员
                     用户:ls----角色：普通用户
                     用户:ww----角色：管理员
                     用户:zl----角色：普通用户
                     用户:tq----角色：普通用户 */

5、linq中的量词（All,Any,Contains）

 　　　//All 所有元素都符合条件返回true 
            bool areAllAdmin = userList.All(u => u.RoleId == 1);   //所有用户的roleid都是1--->false
      //Any 有一个符合条件就返回true
            bool isAnyAdmin = userList.Any(u => u.RoleId == 1);//用户里有没有roleid为1的 --> true
      //Contains 包含返回true
            UserInfo user1=new UserInfo() { UId = 1, UserName = "zs", Age = 23, RoleId = 1 };
            //contains比较的是索引，所以就是list中有一个属性都相同的元素也会返回false,我们可以自定义一个比较类CompareUser来解决这个问题
            bool isContains = userList.Contains(user1);//s索引不同：false
            bool isContains2=userList.Contains(user1,new CompareUser());//自定义比较：true

//自定义的userinfo比较器
    public class CompareUser : IEqualityComparer<UserInfo>
    { 
        public bool Equals(UserInfo x, UserInfo y)
        {
            bool isSame = false;
            //age,username,roleid相同，我们就认为是同一个userinfo
            if (x.Age==y.Age&&x.UserName==y.UserName&&x.RoleId==y.RoleId)
            {
                isSame=true;
            }
            return isSame;
        }
        public int GetHashCode(UserInfo obj)
        {
            throw new NotImplementedException();
        }
    }

6、聚合函数（Average,Count,Max,Min,Sum） 

　　//平均年龄：28.8
            var avgAge = userList.Average(u => u.Age);
   //用户人数：5:  大于30岁的用户人数：2
            var userCount = userList.Count();
            var olduserCount = userList.Count(u => u.Age > 30);
   //最大年龄：42
            var maxAge = userList.Max(u => u.Age);
   //最小年龄：20
            var minAge = userList.Min(u => u.Age);
   //年龄和:144
            var sumAge = userList.Sum(u => u.Age);

7、元素操作符（ElementAt,Frist,Last,Singe和对应的xxxOrDefault）

　　　　这些操作符加上OrDefault后缀后，在超出索引时不会抛出异常，而是返回一个默认值，（如：int返回0 ，引用类型返回null）

 1　　　　 //获取指定索引处的元素
            UserInfo user0 = userList.ElementAt(0);
            UserInfo user9 = userList.ElementAtOrDefault(9);
            //不报错，返回null,没有ordefault后缀会抛异常
       //获取第一个元素
            UserInfo userfrist = userList.First();
            UserInfo userfrist2 = userList.FirstOrDefault();
       //获取最后一个元素
            UserInfo userlast = userList.Last();
            UserInfo userlast2 = userList.LastOrDefault();
       //获取唯一元素（）
            UserInfo userSignal = userList.Single(u => u.Age < 21);
            UserInfo userSignal2 = userList.SingleOrDefault(u => u.Age > 21);
　　　　　　　　　//报错，返回的元素不是唯一的

8、判断序列相等（SequenceEqual）

 //原始类型（字符串、int等，比较顺序和值，这两项都相等时返回true）
            IList<int> intList1 = new List<int> { 1, 2, 3, 4 };
            IList<int> intList2 = new List<int> { 2, 1, 3, 4 };
            //bool isEquel = intList1.SequenceEqual(intList2);

//复杂类型（UserInfo,比较索引，索引相同返回true，可通过自定义比较器修改比较的规则）
            UserInfo user1 = new UserInfo() { UId = 1, UserName = "zs", Age = 23, RoleId = 1 };
            UserInfo user2 = new UserInfo() { UId = 1, UserName = "zs", Age = 23, RoleId = 1 };
            IList<UserInfo> list1 = new List<UserInfo>() { user1 };
            IList<UserInfo> list2 = new List<UserInfo>() { user2};
            //user1和user2的索引不同，返回false
            bool isEquel = list1.SequenceEqual(list2);
            //自定义比较器，只要属性都相等返回true
            bool isEquel2 = list1.SequenceEqual(list2, new CompareUser());
            

    //自定义的userinfo比较器
    public class CompareUser : IEqualityComparer<UserInfo>
    { 
        public bool Equals(UserInfo x, UserInfo y)
        {
            bool isSame = false;
            //age,username,roleid相同，我们就认为是同一个userinfo
            if (x.Age==y.Age&&x.UserName==y.UserName&&x.RoleId==y.RoleId)
            {
                isSame=true;
            }
            return isSame;
        }
        public int GetHashCode(UserInfo obj)
        {
            throw new NotImplementedException();
        }
    }

9、集合操作（Concat、Distinct、Except、Intersect、Union） 

 　　　　//合并 Concat
            IList<UserInfo> list1 = new List<UserInfo>() { user1,user2,user1 };
            IList<UserInfo> list2 = new List<UserInfo>() { user2 ,user2};
            var listConcat = list1.Concat(list2);
　　　　　　　　//包含了user1，user2,user1,user2，user2
       //去重 Distinct（差并交集会自动去重，去重和交差并集中的复杂类型也是根据索引来判断是否相同的，所以视情况自定义比较器）
            var list4 = list1.Distinct();//user1,user2
       //差集(list1中有，list中没有的)  
            var list5 = list1.Except(list2);//user1
       //交集
            var list6 = list1.Intersect(list2);//user2
       //并集
            var list7 = list1.Union(list2);//user1,user2

10、分区（Skip,SkipWhile,Take,TakeWhile）

 　　　　//分区           
            var resUsers = userList.Skip(2);//跳过前2条，返回从第3条到最后一条的记录
            var resUsers2 = userList.SkipWhile(u => u.Age < 30); // 跳过满足条件的数据 
            //结果：从年龄为33的开始，返回后几条

            var resTake = userList.Take(2);//取前2条数据
            var resTake2 = userList.TakeWhile(u => u.Age >= 22);
            //取满足条件的数据，如果连续几条都满足返回多条记录，直到某一条数据不满足条件  
            //结果：返回第一条，如果把条件中22改成20,那么返回所有数据

11、类型转化（As,To，Cast）  select 默认返回的是IEnumerable类型

　　　　　　　var users = from u in userList select u; //IEnumerable<UserInfo>
            var usersEnum = (from u in userList select u).AsEnumerable<UserInfo>();//IEnumerable<UserInfo>
            var usersCast = (from u in userList select u).Cast<UserInfo>();//IEnumerable<UserInfo>,功能和AsEnumerable一样，写着简单
            var usersQuery = (from u in userList select u).AsQueryable<UserInfo>();//IQueryable<UserInfo>
            var usersArray = (from u in userList select u).ToArray<UserInfo>();//UserInfo[]
            var usersList = (from u in userList select u).ToList<UserInfo>();//List<UserInfo>
            var usersDic = (from u in userList select u).ToDictionary<UserInfo,int>(u=>u.UId);//Dictionary<int,UserInfo>