C#对IQueryable、IEnumerable的扩展方法

#region IQueryable的扩展方法

        #region 根据第三方条件是否为真是否执行指定条件的查询
        /// 
        /// 根据第三方条件是否为真是否执行指定条件的查询
        /// 
        /// 动态类型
        /// 要查询的数据源
        /// 条件
        /// 第三方条件
        /// 查询的结果
        public static IQueryable WhereIf(this IQueryable source, Expression> where,
            bool condition)
        {
            if (PublicHelper.CheckArgument(where, "where"))
            {
                return condition ? source.Where(where) : source;
            }
            return null;
        }
        #endregion

        #region 把IQueryable集合按照指定的属性与排序方式进行排序
        /// 
        /// 把IQueryable集合按照指定的属性与排序方式进行排序
        /// 
        /// 数据集类型
        /// 要排序的数据集
        /// 要排序的属性名称
        /// 排序方式
        /// 返回排序后的结果集
        public static IOrderedQueryable OrderBy(this IQueryable source, string propName,
            ListSortDirection listSort = ListSortDirection.Ascending)
        {
            if (PublicHelper.CheckArgument(propName, "propName"))
            {
                return QueryableHelper.OrderBy(source, propName, listSort);
            }
            return null;
        }
        #endregion

        #region 把IQueryable集合按照指定的属性与排序方式进行排序
        /// 
        /// 把IQueryable集合按照指定的属性与排序方式进行排序
        /// 
        /// 数据集类型
        /// 要排序的数据集
        /// 排序条件
        /// 返回排序后的结果集
        public static IOrderedQueryable OrderBy(this IQueryable source, PropertySortCondition sortCondition)
        {
            if (PublicHelper.CheckArgument(sortCondition, "sortCondition"))
            {
                return source.OrderBy(sortCondition.PropertyName, sortCondition.ListSortDirection);
            }
            return null;
        }
        #endregion

        #region 把IOrderedQueryable集合按照指定的属性与排序方式进行再排序
        /// 
        /// 把IOrderedQueryable集合按照指定的属性与排序方式进行排序
        /// 
        /// 数据集类型
        /// 要排序的数据集
        /// 要排序的属性名称
        /// 排序方式
        /// 返回排序后的结果集
        public static IOrderedQueryable ThenBy(this IOrderedQueryable source, string propName,
            ListSortDirection listSort = ListSortDirection.Ascending)
        {
            if (PublicHelper.CheckArgument(propName, "propName"))
            {
                return QueryableHelper.ThenBy(source, propName, listSort);
            }
            return null;
        }
        #endregion

        #region 把IOrderedQueryable集合按照指定的属性与排序方式进行再排序
        /// 
        /// 把IOrderedQueryable集合按照指定的属性与排序方式进行排序
        /// 
        /// 数据集类型
        /// 要排序的数据集
        /// 排序条件
        /// 返回排序后的结果集
        public static IOrderedQueryable ThenBy(this IOrderedQueryable source, PropertySortCondition sortCondition)
        {
            if (PublicHelper.CheckArgument(sortCondition, "sortCondition"))
            {
                return QueryableHelper.ThenBy(source, sortCondition.PropertyName, sortCondition.ListSortDirection);
            }
            return null;
        }
        #endregion

        #region 多条件排序分页查询
        /// 
        /// 把IQueryable集合按照指定的属性与排序方式进行排序后,再按照指定的条件提取指定页码指定条目数据
        /// 
        /// 动态类型
        /// 要排序的数据集
        /// 检索条件
        /// 索引
        /// 页面大小
        /// 总页数
        /// 排序条件
        /// 子集
        public static IQueryable Where(this IQueryable source, Expression> where, int pageIndex,
            int pageSize, out int total, params PropertySortCondition[] sortConditions) where T : class, new()
        {
            IQueryable temp = null;

            int i = 0;
            if (PublicHelper.CheckArgument(source, "source")
                    && PublicHelper.CheckArgument(where, "where")
                    && PublicHelper.CheckArgument(pageIndex, "pageIndex")
                    && PublicHelper.CheckArgument(pageSize, "pageSize")
                    && PublicHelper.CheckArgument(sortConditions, "sortConditions"))
            {
                //判断是不是首个排序条件
                int count = 0;
                //得到满足条件的总记录数
                i = source.Count(where);
                //对数据源进行排序
                IOrderedQueryable orderSource = null;
                foreach (PropertySortCondition sortCondition in sortConditions)
                {
                    orderSource = count == 0
                        ? source.OrderBy(sortCondition.PropertyName, sortCondition.ListSortDirection)
                        : orderSource.ThenBy(sortCondition.PropertyName, sortCondition.ListSortDirection);
                    count++;
                }
                source = orderSource;

                temp = source != null
                    ? source.Where(where).Skip((pageIndex - 1) * pageSize).Skip(pageSize)
                    : Enumerable.Empty().AsQueryable();
            }

            total = i;
            return temp;

            //PublicHelper.CheckArgument(source, "source");
            //PublicHelper.CheckArgument(where, "where");
            //PublicHelper.CheckArgument(pageIndex, "pageIndex");
            //PublicHelper.CheckArgument(pageSize, "pageSize");
            //PublicHelper.CheckArgument(sortConditions, "sortConditions");

            判断是不是首个排序条件
            //int count = 0;
            得到满足条件的总记录数
            //total = source.Count(where);
            对数据源进行排序
            //IOrderedQueryable orderSource = null;
            //foreach (PropertySortCondition sortCondition in sortConditions)
            //{
            //    orderSource = count == 0
            //        ? source.OrderBy(sortCondition.PropertyName, sortCondition.ListSortDirection)
            //        : orderSource.ThenBy(sortCondition.PropertyName, sortCondition.ListSortDirection);
            //    count++;
            //}
            //source = orderSource;

            //return source != null
            //    ? source.Where(where).Skip((pageIndex - 1) * pageSize).Skip(pageSize)
            //    : Enumerable.Empty().AsQueryable();
        }
        #endregion

        #region 多条件排序查询
        / 
        / 多条件排序查询
        / 
        / 动态类型
        / 要排序的数据集
        / 检索条件
        / 排序条件
        / 子集
        //public static IQueryable Where(this IQueryable source, Expression> where, params PropertySortCondition[] sortConditions) where T : class, new()
        //{
        //    log = LogManager.GetLogger(string.Format("查询表_{0}", typeof(T)));
        //    IQueryable temp = null;
        //    Logger("", () =>
        //    {
        //        if (PublicHelper.CheckArgument(source, "source")
        //            && PublicHelper.CheckArgument(where, "where")
        //            && PublicHelper.CheckArgument(sortConditions, "sortConditions"))
        //        {
        //            //判断是不是首个排序条件
        //            int count = 0;
        //            //对数据源进行排序
        //            IOrderedQueryable orderSource = null;
        //            foreach (PropertySortCondition sortCondition in sortConditions)
        //            {
        //                orderSource = count == 0
        //                    ? source.OrderBy(sortCondition.PropertyName, sortCondition.ListSortDirection)
        //                    : orderSource.ThenBy(sortCondition.PropertyName, sortCondition.ListSortDirection);
        //                count++;
        //            }
        //            source = orderSource;

        //            temp = source != null
        //                ? source.Where(where)
        //                : Enumerable.Empty().AsQueryable();
        //        }
        //    });
        //    return temp;
        //}
        #endregion

        #endregion

        #region IEnumerable的扩展方法

        #region 将集合展开分别转换成字符串,再以指定分隔字符串链接,拼成一个字符串返回
        /// 
        /// 将集合展开分别转换成字符串,再以指定分隔字符串链接,拼成一个字符串返回
        /// 
        /// 动态类型
        /// 要处理的集合
        /// 分隔符
        /// 拼接后的字符串
        public static string ExpandAndToString(this IEnumerable collection, string separator)
        {
            List source = collection as List ?? collection.ToList();
            if (source.IsEmpty())
            {
                return "";
            }

            string result = source.Cast()
                 .Aggregate(null, (current, o) => current + String.Format("{0}{1}", o, separator));

            return result.Substring(0, result.LastIndexOf(separator, StringComparison.Ordinal));
        }
        #endregion

        #region 根据指定条件返回集合中不重复的元素
        /// 
        /// 根据指定条件返回集合中不重复的元素
        /// 
        /// 动态类型
        /// 动态筛选条件类型
        /// 要操作的数据源
        /// 重复数据的筛选条件
        /// 不重复元素的集合
        public static IEnumerable DistinctBy(this IEnumerable source, Func keySelector)
        {
            //取分组集合中每组的第一条数据
            return source.GroupBy(keySelector).Select(group => group.First());
        }
        #endregion

        #region 根据第三方条件是否为真是否执行指定条件的查询
        /// 
        /// 根据第三方条件是否为真是否执行指定条件的查询
        /// 
        /// 动态类型
        /// 要查询的数据源
        /// 条件
        /// 第三方条件
        /// 查询的结果
        public static IEnumerable WhereIf(this IEnumerable source, Func where,
            bool condition)
        {
            return condition ? source.Where(where) : source;
        }
        #endregion

        #region 判断集合是否为空
        /// 
        /// 判断集合是否为空
        /// 
        /// 动态类型
        /// 要处理的集合
        /// 集合为空返回true 不为空返回false
        public static bool IsEmpty(this IEnumerable collection)
        {
            return !collection.Any();
        }
        #endregion

        #endregion

        #region 其他
        /// 
        /// 扩展Between 操作符
        /// 使用 var query = db.People.Between(person => person.Age, 18, 21);
        /// 
        /// 
        /// 
        /// 当前值
        /// 拉姆达表达式
        /// 低
        /// 高
        /// 
        public static IQueryable Between(this IQueryable source, Expression> keySelector, TKey low, TKey high) where TKey : IComparable
        {
            Expression key = Expression.Invoke(keySelector, keySelector.Parameters.ToArray());

            Expression lowerBound = Expression.GreaterThanOrEqual(key, Expression.Constant(low));

            Expression upperBound = Expression.LessThanOrEqual(key, Expression.Constant(high));

            Expression and = Expression.AndAlso(lowerBound, upperBound);

            Expression> lambda = Expression.Lambda>(and, keySelector.Parameters);

            return source.Where(lambda);
        }

        /// 
        /// In
        /// 
        /// 
        /// 
        /// 
        /// 
        public static bool In(this T value, params T[] values)
        {
            return values.Contains(value);
        }

        /// 
        /// Between
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static bool Between(this T i, T start, T end) where T : IComparable
        {
            return i.CompareTo(start) >= 0 && i.CompareTo(end) <= 0;
        }

        /// 
        /// And
        /// 
        /// 
        /// 
        /// 
        public static bool And(this bool left, bool right)
        {
            return left && right;
        }

        /// 
        /// Or
        /// 
        /// 
        /// 
        /// 
        public static bool Or(this bool left, bool right)
        {
            return left || right;
        }

        #endregion
 
    
   

  

转载于:https://www.cnblogs.com/zhao-yi/p/7205159.html

你可能感兴趣的:(c#)