LambdaHelper

public class LambdaHelper
 {
     /*
      * ●from子句：指定查询操作的数据源和范围变量。
      *
      * ●select子句：指定查询结果的类型和表现形式。
      *
      * ●where子句：指定筛选元素的逻辑条件。
      *
      * ●let子句：引入用来临时保存查询表达式中的字表达式结果的范围变量。
      *
      * ●orderby子句：对查询结果进行排序操作，包括升序和降序。
      *
      * ●group子句：对查询结果进行分组。
      *
      * ●into子句：提供一个临时标识符。join子句、group子句或select子句可以通过该标识符引用查询操作中的中坚结果。
      *
      * ●join子句：连接多个用于查询操作的数据源
      */

     /// <summary>
     /// 获取List
     /// </summary>
     /// <returns></returns>
     public List<UsersModel> GetUsersList()
     {
         List<UsersModel> list = new List<UsersModel>();
         return list;
     }

     #region 拉姆达表达式实现Sum、Min、Max操作

     #region GetIntSum 对GetIntSum类型进行求和
     /// <summary>
     ///GetIntSum  求和int
     /// </summary>
     /// <returns></returns>
     public int GetIntSum()
     {
         List<UsersModel> usersModels = new List<UsersModel>();
         //获取sum的合计数据
         int sumNum = usersModels.Where(cp => cp.UpdateUser > 0).Sum(cp => cp.UpdateUser);

         //获取最大值
         var maxNum = usersModels.Max(cp => cp.UpdateUser);

         //获取最小值
         var minNum = usersModels.Min(cp => cp.UpdateUser);

         //查询最大的一条数据
         usersModels.OrderByDescending(cp => cp.UserID).FirstOrDefault();
         return maxNum;
     }
     #endregion

     #region GetDoubleSum 对Double类型进行求和
     /// <summary>
     /// 对doubel类型进行求和
     /// </summary>
     /// <returns></returns>
     public void GetDoubleSum()
     {
         List<UsersModel> usersModels = new List<UsersModel>();

         //获取doubleSum的合计数据
         double doubleSum = usersModels.Where(cp => cp.DoubleMoney > 0).Sum(cp => cp.DoubleMoney);

         //获取最大值
         double maxNum = usersModels.Max(cp => cp.DoubleMoney);

         //获取最小值
         double minNum = usersModels.Min(cp => cp.DoubleMoney);
     }

     #endregion

     #region GetDecimalSum 对Decimal类型进行求和
     /// <summary>
     /// 对Decimal类型进行求和
     /// </summary>
     public void GetDecimalSum()
     {
         List<UsersModel> usersModels = new List<UsersModel>();

         //获取doubleSum的合计数据
         decimal doubleSum = usersModels.Where(cp => cp.Money > 0).Sum(cp => cp.Money);

         //获取最大值
         decimal maxNum = usersModels.Max(cp => cp.Money);

         //获取最小值
         decimal minNum = usersModels.Min(cp => cp.Money);

     }
     #endregion

     #endregion

     #region 拉姆达表达式实现forEash循环
     /// <summary>
     /// 拉姆达表达式实现for循环
     /// </summary>
     public void ForEachToLambda()
     {
         var usersModels = GetUsersList();
         usersModels.ForEach(a =>
         {
             if (a.UpdateUser > 20)
             {
                 //这里继续调用某一个方法
                 Console.WriteLine(a.UpdateUser);
             }
         });
     }
     #endregion

     #region 拉姆达表达式实现where筛选
     /// <summary>
     /// 条件筛选 where
     /// </summary>
     public void ConditionScreen()
     {
         var usersModels = GetUsersList();
         // 条件筛选 where单个
         var model = usersModels.Where(cp => cp.UpdateTime > DateTime.Now).FirstOrDefault();
         // 条件筛选 whereList
         var usersList = usersModels.Where(cp => cp.UpdateTime > DateTime.Now && cp.UpdateUser > 0);
         //升序
         var listAsc = usersModels.OrderBy(cp => cp.UpdateTime).ToList();
         //降序
         var listDes = usersModels.OrderByDescending(cp => cp.UpdateTime).ToList();
         //包含p.Name.Contains
         var containsList = usersModels.Select(cp => cp.UserName.Contains("demo")).ToList();
     }
     #endregion

     #region 拉姆达表达式实现GroupBy筛选
     /// <summary>
     /// 对list进行分组
     /// </summary>
     public void GroupByList()
     {
         var usersModels = GetUsersList();

         //单一:根据用户进行分组
         var dic = usersModels.GroupBy(a => a.CreateUser);

         foreach (var item in dic)
         {
             Console.WriteLine(item.Key);
             foreach (var sub in item)
             {
                 Console.WriteLine("\t\t" + sub.UpdateTime + " " + sub.UpdateUser);
             }
         }
         //
         var dic2 = usersModels.GroupBy(a => a.CreateUser, a => a.CreateTime).ToList();

         //多个条件进行分组GroupBy
         var group = usersModels.GroupBy(x => new { x.CreateTime, x.UpdateUser, x.UserID, x.UserName }).ToList();
     }
     #endregion

     #region 拉姆达表达式实现Select操作
     /// <summary>
     /// 拉姆达表达式实现Select操作
     /// </summary>
     public void LambdaBySelectList()
     {
         var list = GetUsersList();
         //1.获取userNameList
         List<string> userNameList = list.Select(cp => cp.UserName).ToList();
         //2.获取userNameList 中第一条条数据
         string str = list.Select(cp => cp.UserName).FirstOrDefault();
         //3.获取满足条件的第一条记录
         UsersModel usersModel = list.Where(cp => cp.UserName== "Manager"&& cp.UserID>0).FirstOrDefault();

         //4.Skip 排序后获取List中的前10条记录
         List<UsersModel> skipList= list.Skip(10).ToList();

         //5.获取List某一字段的平均值
         var averNum = list.Average(cp => cp.UserID);

     }

     #endregion

     #region linq 表达式的使用
     /// <summary>
     /// linq 表达式的使用
     /// </summary>
     public void GetLinq()
     {
         int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
         var query2 = from n in arr
                      where n > 6
                      select n;

         List<UsersModel> usersModels = new List<UsersModel>();
         var selectUserList = from user in usersModels where user.IsValid > 0 select user;
     }
     #endregion

 }
 ~~~