Linq 实现动态查询

• 直接上代码

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace RfSoft.MapleTr.Controllers.Utilities
{
    public static class LinqDynamicQuery
    {
        /// <summary>
        /// Linq动态查询
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sourceList"></param>
        /// <param name="queryConditionList"></param>
        /// <param name="orderByConditionList"></param>
        /// <returns></returns>
        public static IEnumerable<T> GetDataByDynamicQuery<T>(this IEnumerable<T> sourceList, List<QueryCondition> queryConditionList, params OrderByCondition[] orderByConditionList)
        {
            if (null == sourceList)
            {
                throw new ArgumentException("数据源不能为空");
            }

            IQueryable<T> sourceLs = sourceList.AsQueryable();

            Expression finalExpr;
            Expression filter, totalExpr;
            filter = totalExpr = Expression.Constant(true);

            ParameterExpression param = Expression.Parameter(typeof(T), "n");
            foreach (var item in queryConditionList ?? Enumerable.Empty<QueryCondition>())
            {
                //反射找出所有查询条件的属性值，如果该查询条件值为空或者null不添加动态lambda表达式
                string propertyName = item.ConditionField;
                var propertyVal = item.FieldValue;
                if (null != propertyVal)
                {
                    propertyVal = propertyVal.Trim();
                }
                if (!string.IsNullOrEmpty(propertyName) && propertyVal != null && propertyVal.ToString() != string.Empty)
                {
                    //n.property
                    PropertyInfo property = typeof(T).GetProperty(propertyName);
                    Expression left = Expression.Property(param, property);
                    //等式右边的值
                    Expression right = Expression.Constant(propertyVal);

                    //当前字段类型
                    Type propertyType = property.PropertyType;
                    //对可空数据类型的处理
                    if (propertyType.IsGenericType)
                    {
                        Type genericTypeDefinition = propertyType.GetGenericTypeDefinition();
                        if (genericTypeDefinition == typeof(Nullable<>))
                        {
                            NullableConverter nullableDataType = new NullableConverter(propertyType);
                            right = Expression.Constant(nullableDataType.ConvertFromString(propertyVal), propertyType);
                        }
                    }
                    else
                    {
                        right = Expression.Constant(Convert.ChangeType(propertyVal, propertyType), propertyType);
                    }

                    MethodInfo containsmethod;
                    switch (item.Relation)
                    {
                        case RelationFlags.Equal:
                            if (typeof(string) == property.PropertyType)
                            {
                                containsmethod = typeof(string).GetMethod("Equals", new[] { typeof(string), typeof(string), typeof(StringComparison) });

                                filter = Expression.Call(containsmethod, left, right, Expression.Constant(StringComparison.OrdinalIgnoreCase));
                            }
                            else
                            {
                                filter = Expression.Equal(left, right);
                            }
                            break;
                        case RelationFlags.NoEqual:
                            filter = Expression.NotEqual(left, right);
                            break;
                        case RelationFlags.GreaterThan:
                            filter = Expression.GreaterThan(left, right);
                            break;
                        case RelationFlags.LessThan:
                            filter = Expression.LessThan(left, right);
                            break;
                        case RelationFlags.GreaterThanOrEqual:
                            filter = Expression.GreaterThanOrEqual(left, right);
                            break;
                        case RelationFlags.LessThanOrEqual:
                            filter = Expression.LessThanOrEqual(left, right);
                            break;
                        case RelationFlags.LikeWildcardBoth:
                            if (typeof(string) == property.PropertyType)
                            {
                                containsmethod = property.PropertyType.GetMethod("Contains", new Type[] { property.PropertyType });
                                filter = Expression.Call(left, containsmethod, right);
                            }
                            else
                            {
                                throw new ArgumentException(" 'like %x%' operator work on string type only ");
                            }
                            break;
                        case RelationFlags.LikeLeftWildcardOnly:
                            if (typeof(string) == property.PropertyType)
                            {
                                containsmethod = property.PropertyType.GetMethod("EndsWith", new Type[] { property.PropertyType });
                                filter = Expression.Call(left, containsmethod, right);
                            }
                            else
                            {
                                throw new ArgumentException(" 'like %x' operator work on string type only ");
                            }
                            break;
                        case RelationFlags.LikeRightWildcardOnly:
                            if (typeof(string) == property.PropertyType)
                            {
                                containsmethod = property.PropertyType.GetMethod("StartsWith", new Type[] { property.PropertyType });
                                filter = Expression.Call(left, containsmethod, right);
                            }
                            else
                            {
                                throw new ArgumentException(" 'like x%' operator work on string type only ");
                            }
                            break;
                        case RelationFlags.In:
                            Expression rightTmp, filterTmp;
                            Expression totalExprTmp = Expression.Constant(false);
                            foreach (var itemValue in propertyVal as IEnumerable ?? Enumerable.Empty<object>())
                            {
                                rightTmp = Expression.Constant(itemValue);
                                if (typeof(string) == property.PropertyType)
                                {
                                    containsmethod = typeof(string).GetMethod("Equals", new[] { typeof(string), typeof(string), typeof(StringComparison) });
                                    filterTmp = Expression.Call(containsmethod, left, rightTmp, Expression.Constant(StringComparison.OrdinalIgnoreCase));
                                }
                                else
                                {
                                    filterTmp = Expression.Equal(left, rightTmp);
                                }
                                totalExprTmp = Expression.Or(filterTmp, totalExprTmp);
                            }
                            filter = totalExprTmp = Expression.And(totalExprTmp, Expression.Constant(true));
                            break;
                        default:
                            filter = Expression.Constant(true);
                            break;
                    }
                    switch (item.Condition)
                    {
                        case ConditionFlags.And:
                            totalExpr = Expression.And(totalExpr, filter);
                            break;
                        case ConditionFlags.Or:
                            totalExpr = Expression.Or(totalExpr.NodeType.Equals(Expression.Constant(true).NodeType) ? Expression.Constant(false) : totalExpr, filter);
                            break;
                        default:
                            break;
                    }
                }
            }
            //Where部分条件
            Expression pred = Expression.Lambda(totalExpr, param);
            finalExpr = Expression.Call(typeof(Queryable), "Where", new Type[] { typeof(T) }, Expression.Constant(sourceLs), pred);
            string orderByFunctionName = "OrderBy";
            string orderByDescFunctionName = "OrderByDescending";
            foreach (var orderbyCondition in orderByConditionList ?? Enumerable.Empty<OrderByCondition>())
            {
                PropertyInfo pInfo = typeof(T).GetProperty(orderbyCondition.OrderField);
                //OrderBy部分排序
                finalExpr = Expression.Call(typeof(Queryable), orderbyCondition.IsDesc ? orderByDescFunctionName : orderByFunctionName, new Type[] { typeof(T), pInfo.PropertyType }, finalExpr, Expression.Lambda(Expression.Property(param, pInfo), param));
                orderByFunctionName = "ThenBy";
                orderByDescFunctionName = "ThenByDescending";
            }

            return sourceLs.Provider.CreateQuery<T>(finalExpr);
        }
    }

    public enum ConditionFlags
    {
        And = 0,
        Or = 1,
    }

    public enum RelationFlags
    {
        /// <summary>
        /// 等于
        /// </summary>
        Equal = 0,

        /// <summary>
        /// 不等于
        /// </summary>
        NoEqual = 1,

        /// <summary>
        /// 大于
        /// </summary>
        GreaterThan = 2,

        /// <summary>
        /// 小于
        /// </summary>
        LessThan = 3,

        /// <summary>
        /// 大于等于
        /// </summary>
        GreaterThanOrEqual = 4,

        /// <summary>
        /// 小于等于
        /// </summary>
        LessThanOrEqual = 5,

        /// <summary>
        /// like "%xxxx%"
        /// </summary>
        LikeWildcardBoth = 6,

        /// <summary>
        /// like "%xxx"
        /// </summary>
        LikeLeftWildcardOnly = 7,

        /// <summary>
        /// like "xxx%"
        /// </summary>
        LikeRightWildcardOnly = 8,

        /// <summary>
        /// 包含，多个值
        /// </summary>
        In = 9,
    }

    public class QueryCondition
    {
        public string ConditionField { get; set; }
        public string FieldValue { get; set; }
        public ConditionFlags Condition { get; set; }
        public RelationFlags Relation { get; set; }
    }

    public class OrderByCondition
    {
        public string OrderField { get; set; }
        public bool IsDesc { get; set; }
    }
}