動態構造任意復雜的 Linq Where 表達式

前言

       Linq 是 C# 中一個非常好用的集合處理庫，用好了能幫我們簡化大量又臭又長的嵌套循環，使處理邏輯清晰可見。EF 查詢主要也是依賴 Linq。但是 Linq 相對 sql 也存在一些缺點，最主要的就是動態構造查詢的難度。sql 只需要簡單進行字符串拼接，操作難度很低（當然出錯也相當容易），而 Linq 表達式由於對強類型表達式樹的依賴，動態構造查詢表達式基本相當於手寫 AST（抽象語法樹），可以說難度暴增。

       AST 已經進入編譯原理的領域，對計算機系統的了解程度需求比一般 crud 寫業務代碼高了幾個量級，也導致很多人覺得 EF 不好用，為了寫個動態查詢要學編譯原理這個代價還是挺高的。后來也有一些類似 DynamicLinq 的類庫能用表達式字符串寫動態查詢。

       本着學習精神，研究了一段時間，寫了一個在我的想象力范圍內，可以動態構造任意復雜的 Where 表達式的輔助類。這個輔助類的過濾條件使用了 JqGrid 的高級查詢的數據結構，這是我第一個知道能生成復雜嵌套查詢，並且查詢數據使用 json 方便解析的 js 表格插件。可以無縫根據 JqGrid 的高級查詢生成 Where 表達式。

正文

實現

       JqGrid 高級查詢數據結構定義，用來反序列化：

    public class JqGridParameter
    {
        /// <summary>
        /// 是否搜索，本來應該是bool，true
        /// </summary>
        public string _search { get; set; }
        /// <summary>
        /// 請求發送次數，方便服務器處理重復請求
        /// </summary>
        public long Nd { get; set; }
        /// <summary>
        /// 當頁數據條數
        /// </summary>
        public int Rows { get; set; }
        /// <summary>
        /// 頁碼
        /// </summary>
        public int Page { get; set; }
        /// <summary>
        /// 排序列，多列排序時為排序列名+空格+排序方式，多個列之間用逗號隔開。例：id asc,name desc
        /// </summary>
        public string Sidx { get; set; }
        /// <summary>
        /// 分離后的排序列
        /// </summary>
        public string[][] SIdx => Sidx.Split(", ").Select(s => s.Split(" ")).ToArray();
        /// <summary>
        /// 排序方式：asc、desc
        /// </summary>
        public string Sord { get; set; }
        /// <summary>
        /// 高級搜索條件json
        /// </summary>
        public string Filters { get; set; }

        /// <summary>
        /// 序列化的高級搜索對象
        /// </summary>
        public JqGridSearchRuleGroup FilterObject => Filters.IsNullOrWhiteSpace()
            ? new JqGridSearchRuleGroup { Rules = new[] { new JqGridSearchRule { Op = SearchOper, Data = SearchString, Field = SearchField } } }
            : JsonSerializer.Deserialize<JqGridSearchRuleGroup>(Filters ?? string.Empty);

        /// <summary>
        /// 簡單搜索字段
        /// </summary>
        public string SearchField { get; set; }
        /// <summary>
        /// 簡單搜索關鍵字
        /// </summary>
        public string SearchString { get; set; }
        /// <summary>
        /// 簡單搜索操作
        /// </summary>
        public string SearchOper { get; set; }

    }

    /// <summary>
    /// 高級搜索條件組
    /// </summary>
    public class JqGridSearchRuleGroup
    {
        /// <summary>
        /// 條件組合方式：and、or
        /// </summary>
        public string GroupOp { get; set; }
        /// <summary>
        /// 搜索條件集合
        /// </summary>
        public JqGridSearchRule[] Rules { get; set; }
        /// <summary>
        /// 搜索條件組集合
        /// </summary>
        public JqGridSearchRuleGroup[] Groups { get; set; }
    }

    /// <summary>
    /// 高級搜索條件
    /// </summary>
    public class JqGridSearchRule
    {
        /// <summary>
        /// 搜索字段
        /// </summary>
        public string Field { get; set; }
        /// <summary>
        /// 搜索字段的大駝峰命名
        /// </summary>
        public string PascalField => Field?.Length > 0 ? Field.Substring(0, 1).ToUpper() + Field.Substring(1) : Field;
        /// <summary>
        /// 搜索操作
        /// </summary>
        public string Op { get; set; }
        /// <summary>
        /// 搜索關鍵字
        /// </summary>
        public string Data { get; set; }
    }

       Where 條件生成器，代碼有點多，有點復雜。不過注釋也很多，稍微耐心點應該不難看懂：

    /// <summary>
    /// JqGrid搜索表達式擴展
    /// </summary>
    public static class JqGridSearchExtensions
    {
        //前端的（不）屬於條件搜索需要傳遞一個json數組的字符串作為參數
        //為了避免在搜索字符串的時候分隔符是搜索內容的一部分導致搜索關鍵字出錯
        //無論定義什么分隔符都不能完全避免這種尷尬的情況，所以使用標准的json以絕后患
        /// <summary>
        /// 根據搜索條件構造where表達式，支持JqGrid高級搜索
        /// </summary>
        /// <typeparam name="T">搜索的對象類型</typeparam>
        /// <param name="ruleGroup">JqGrid搜索條件組</param>
        /// <param name="propertyMap">屬性映射，把搜索規則的名稱映射到屬性名稱，如果屬性是復雜類型，使用點號可以繼續訪問內部屬性</param>
        /// <returns>where表達式</returns>
        public static Expression<Func<T, bool>> BuildWhere<T>(JqGridSearchRuleGroup ruleGroup, IDictionary<string, string> propertyMap)
        {
            ParameterExpression parameter = Expression.Parameter(typeof(T), "searchObject");

            return Expression.Lambda<Func<T, bool>>(BuildGroupExpression<T>(ruleGroup, parameter, propertyMap), parameter);
        }

        /// <summary>
        /// 構造搜索條件組的表達式（一個組中可能包含若干子條件組）
        /// </summary>
        /// <typeparam name="T">搜索的對象類型</typeparam>
        /// <param name="group">條件組</param>
        /// <param name="parameter">參數表達式</param>
        /// <param name="propertyMap">屬性映射</param>
        /// <returns>返回bool的條件組的表達式</returns>
        private static Expression BuildGroupExpression<T>(JqGridSearchRuleGroup group, ParameterExpression parameter, IDictionary<string, string> propertyMap)
        {
            List<Expression> expressions = new List<Expression>();
            foreach (var rule in group.Rules ?? new JqGridSearchRule[0])
            {
                expressions.Add(BuildRuleExpression<T>(rule, parameter, propertyMap));
            }

            foreach (var subGroup in group.Groups ?? new JqGridSearchRuleGroup[0])
            {
                expressions.Add(BuildGroupExpression<T>(subGroup, parameter, propertyMap));
            }

            if (expressions.Count == 0)
            {
                throw new InvalidOperationException("構造where子句異常，生成了0個比較條件表達式。");
            }

            if (expressions.Count == 1)
            {
                return expressions[0];
            }

            var expression = expressions[0];
            switch (group.GroupOp)
            {
                case "AND":
                    foreach (var exp in expressions.Skip(1))
                    {
                        expression = Expression.AndAlso(expression, exp);
                    }
                    break;
                case "OR":
                    foreach (var exp in expressions.Skip(1))
                    {
                        expression = Expression.OrElse(expression, exp);
                    }
                    break;
                default:
                    throw new InvalidOperationException($"不支持創建{group.GroupOp}類型的邏輯運算表達式");
            }

            return expression;
        }

        private static readonly string[] SpecialRuleOps = {"in", "ni", "nu", "nn"};

        /// <summary>
        /// 構造條件表達式
        /// </summary>
        /// <typeparam name="T">搜索的對象類型</typeparam>
        /// <param name="rule">條件</param>
        /// <param name="parameter">參數</param>
        /// <param name="propertyMap">屬性映射</param>
        /// <returns>返回bool的條件表達式</returns>
        private static Expression BuildRuleExpression<T>(JqGridSearchRule rule, ParameterExpression parameter,
            IDictionary<string, string> propertyMap)
        {
            Expression l;

            string[] names = null;
            //如果實體屬性名稱和前端名稱不一致，或者屬性是一個自定義類型，需要繼續訪問其內部屬性，使用點號分隔
            if (propertyMap?.ContainsKey(rule.Field) == true)
            {
                names = propertyMap[rule.Field].Split('.', StringSplitOptions.RemoveEmptyEntries);
                l = Expression.Property(parameter, names[0]);
                foreach (var name in names.Skip(1))
                {
                    l = Expression.Property(l, name);
                }
            }
            else
            {
                l = Expression.Property(parameter, rule.PascalField);
            }

            Expression r = null; //值表達式
            Expression e; //返回bool的各種比較表達式

            //屬於和不屬於比較是多值比較，需要調用Contains方法，而不是調用比較操作符
            //為空和不為空的右值為常量null，不需要構造
            var specialRuleOps = SpecialRuleOps;

            var isNullable = false;
            var pt = typeof(T);
            if(names != null)
            {
                foreach(var name in names)
                {
                    pt = pt.GetProperty(name).PropertyType;
                }
            }
            else
            {
                pt = pt.GetProperty(rule.PascalField).PropertyType;
            }

            //如果屬性類型是可空值類型，取出內部類型
            if (pt.IsDerivedFrom(typeof(Nullable<>)))
            {
                isNullable = true;
                pt = pt.GenericTypeArguments[0];
            }

            //根據屬性類型創建要比較的常量值表達式（也就是r）
            if (!specialRuleOps.Contains(rule.Op))
            {
                switch (pt)
                {
                    case Type ct when ct == typeof(bool):
                        r = BuildConstantExpression(rule, bool.Parse);
                        break;

                    #region 文字

                    case Type ct when ct == typeof(char):
                        r = BuildConstantExpression(rule, str => str[0]);
                        break;
                    case Type ct when ct == typeof(string):
                        r = BuildConstantExpression(rule, str => str);
                        break;

                    #endregion

                    #region 有符號整數

                    case Type ct when ct == typeof(sbyte):
                        r = BuildConstantExpression(rule, sbyte.Parse);
                        break;
                    case Type ct when ct == typeof(short):
                        r = BuildConstantExpression(rule, short.Parse);
                        break;
                    case Type ct when ct == typeof(int):
                        r = BuildConstantExpression(rule, int.Parse);
                        break;
                    case Type ct when ct == typeof(long):
                        r = BuildConstantExpression(rule, long.Parse);
                        break;

                    #endregion

                    #region 無符號整數

                    case Type ct when ct == typeof(byte):
                        r = BuildConstantExpression(rule, byte.Parse);
                        break;
                    case Type ct when ct == typeof(ushort):
                        r = BuildConstantExpression(rule, ushort.Parse);
                        break;
                    case Type ct when ct == typeof(uint):
                        r = BuildConstantExpression(rule, uint.Parse);
                        break;
                    case Type ct when ct == typeof(ulong):
                        r = BuildConstantExpression(rule, ulong.Parse);
                        break;

                    #endregion

                    #region 小數

                    case Type ct when ct == typeof(float):
                        r = BuildConstantExpression(rule, float.Parse);
                        break;
                    case Type ct when ct == typeof(double):
                        r = BuildConstantExpression(rule, double.Parse);
                        break;
                    case Type ct when ct == typeof(decimal):
                        r = BuildConstantExpression(rule, decimal.Parse);
                        break;

                    #endregion

                    #region 其它常用類型

                    case Type ct when ct == typeof(DateTime):
                        r = BuildConstantExpression(rule, DateTime.Parse);
                        break;
                    case Type ct when ct == typeof(DateTimeOffset):
                        r = BuildConstantExpression(rule, DateTimeOffset.Parse);
                        break;
                    case Type ct when ct == typeof(Guid):
                        r = BuildConstantExpression(rule, Guid.Parse);
                        break;
                    case Type ct when ct.IsEnum:
                        r = Expression.Constant(rule.Data.ToEnumObject(ct));
                        break;

                    #endregion

                    default:
                        throw new InvalidOperationException($"不支持創建{pt.FullName}類型的數據表達式");
                }
            }

            if (r != null && pt.IsValueType && isNullable)
            {
                var gt = typeof(Nullable<>).MakeGenericType(pt);
                r = Expression.Convert(r, gt);
            }

            switch (rule.Op)
            {
                case "eq": //等於
                    e = Expression.Equal(l, r);
                    break;
                case "ne": //不等於
                    e = Expression.NotEqual(l, r);
                    break;
                case "lt": //小於
                    e = Expression.LessThan(l, r);
                    break;
                case "le": //小於等於
                    e = Expression.LessThanOrEqual(l, r);
                    break;
                case "gt": //大於
                    e = Expression.GreaterThan(l, r);
                    break;
                case "ge": //大於等於
                    e = Expression.GreaterThanOrEqual(l, r);
                    break;
                case "bw": //開頭是（字符串）
                    if (pt == typeof(string))
                    {
                        e = Expression.Call(l, pt.GetMethod(nameof(string.StartsWith), new[] {typeof(string)}), r);
                    }
                    else
                    {
                        throw new InvalidOperationException($"不支持創建{pt.FullName}類型的開始於表達式");
                    }

                    break;
                case "bn": //開頭不是（字符串）
                    if (pt == typeof(string))
                    {
                        e = Expression.Not(Expression.Call(l, pt.GetMethod(nameof(string.StartsWith), new[] {typeof(string)}), r));
                    }
                    else
                    {
                        throw new InvalidOperationException($"不支持創建{pt.FullName}類型的不開始於表達式");
                    }

                    break;
                case "ew": //結尾是（字符串）
                    if (pt == typeof(string))
                    {
                        e = Expression.Call(l, pt.GetMethod(nameof(string.EndsWith), new[] {typeof(string)}), r);
                    }
                    else
                    {
                        throw new InvalidOperationException($"不支持創建{pt.FullName}類型的結束於表達式");
                    }

                    break;
                case "en": //結尾不是（字符串）
                    if (pt == typeof(string))
                    {
                        e = Expression.Not(Expression.Call(l, pt.GetMethod(nameof(string.EndsWith), new[] {typeof(string)}), r));
                    }
                    else
                    {
                        throw new InvalidOperationException($"不支持創建{pt.FullName}類型的不結束於表達式");
                    }

                    break;
                case "cn": //包含（字符串）
                    if (pt == typeof(string))
                    {
                        e = Expression.Call(l, pt.GetMethod(nameof(string.Contains), new[] {typeof(string)}), r);
                    }
                    else
                    {
                        throw new InvalidOperationException($"不支持創建{pt.FullName}類型的包含表達式");
                    }

                    break;
                case "nc": //不包含（字符串）
                    if (pt == typeof(string))
                    {
                        e = Expression.Not(Expression.Call(l, pt.GetMethod(nameof(string.Contains), new[] {typeof(string)}), r));
                    }
                    else
                    {
                        throw new InvalidOperationException($"不支持創建{pt.FullName}類型的包含表達式");
                    }

                    break;
                case "in": //屬於（是候選值列表之一）
                    e = BuildContainsExpression(rule, l, pt);
                    break;
                case "ni": //不屬於（不是候選值列表之一）
                    e = Expression.Not(BuildContainsExpression(rule, l, pt));
                    break;
                case "nu": //為空
                    r = Expression.Constant(null);
                    e = Expression.Equal(l, r);
                    break;
                case "nn": //不為空
                    r = Expression.Constant(null);
                    e = Expression.Not(Expression.Equal(l, r));
                    break;
                case "bt": //區間
                    throw new NotImplementedException($"尚未實現創建{rule.Op}類型的比較表達式");
                default:
                    throw new InvalidOperationException($"不支持創建{rule.Op}類型的比較表達式");
            }

            return e;

            static Expression BuildConstantExpression<TValue>(JqGridSearchRule jRule, Func<string, TValue> valueConvertor)
            {
                var rv = valueConvertor(jRule.Data);
                return Expression.Constant(rv);
            }
        }

        /// <summary>
        /// 構造Contains調用表達式
        /// </summary>
        /// <param name="rule">條件</param>
        /// <param name="parameter">參數</param>
        /// <param name="parameterType">參數類型</param>
        /// <returns>Contains調用表達式</returns>
        private static Expression BuildContainsExpression(JqGridSearchRule rule, Expression parameter, Type parameterType)
        {
            Expression e = null;

            var genMethod = typeof(Queryable).GetMethods()
                .Single(m => m.Name == nameof(Queryable.Contains) && m.GetParameters().Length == 2);

            var jsonArray = JsonSerializer.Deserialize<string[]>(rule.Data);

            switch (parameterType)
            {
                #region 文字

                case Type ct when ct == typeof(char):
                    if (jsonArray.Any(o => o.Length != 1)) {throw new InvalidOperationException("字符型的候選列表中存在錯誤的候選項");}
                    e = CallContains(parameter, jsonArray, str => str[0], genMethod, ct);
                    break;
                case Type ct when ct == typeof(string):
                    e = CallContains(parameter, jsonArray, str => str, genMethod, ct);
                    break;

                #endregion

                #region 有符號整數

                case Type ct when ct == typeof(sbyte):
                    e = CallContains(parameter, jsonArray, sbyte.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(short):
                    e = CallContains(parameter, jsonArray, short.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(int):
                    e = CallContains(parameter, jsonArray, int.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(long):
                    e = CallContains(parameter, jsonArray, long.Parse, genMethod, ct);
                    break;

                #endregion

                #region 無符號整數

                case Type ct when ct == typeof(byte):
                    e = CallContains(parameter, jsonArray, byte.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(ushort):
                    e = CallContains(parameter, jsonArray, ushort.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(uint):
                    e = CallContains(parameter, jsonArray, uint.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(ulong):
                    e = CallContains(parameter, jsonArray, ulong.Parse, genMethod, ct);
                    break;

                #endregion

                #region 小數

                case Type ct when ct == typeof(float):
                    e = CallContains(parameter, jsonArray, float.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(double):
                    e = CallContains(parameter, jsonArray, double.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(decimal):
                    e = CallContains(parameter, jsonArray, decimal.Parse, genMethod, ct);
                    break;

                #endregion

                #region 其它常用類型

                case Type ct when ct == typeof(DateTime):
                    e = CallContains(parameter, jsonArray, DateTime.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(DateTimeOffset):
                    e = CallContains(parameter, jsonArray, DateTimeOffset.Parse, genMethod, ct);
                    break;
                case Type ct when ct == typeof(Guid):
                    e = CallContains(parameter, jsonArray, Guid.Parse, genMethod, ct);
                    break;
                case Type ct when ct.IsEnum:
                    e = CallContains(Expression.Convert(parameter, typeof(object)), jsonArray, enumString => enumString.ToEnumObject(ct), genMethod, ct);
                    break;

                    #endregion
            }

            return e;

            static MethodCallExpression CallContains<T>(Expression pa, string[] jArray, Func<string, T> selector, MethodInfo genericMethod, Type type)
            {
                var data = jArray.Select(selector).ToArray().AsQueryable();
                var method = genericMethod.MakeGenericMethod(type);

                return Expression.Call(null, method, new[] { Expression.Constant(data), pa });
            }
        }
    }

使用

       此處是在 Razor Page 中使用，內部使用的其他輔助類和前端頁面代碼就不貼了，有興趣的可以在我的文章末尾找到 GitHub 項目鏈接：

        public async Task<IActionResult> OnGetUserListAsync([FromQuery]JqGridParameter jqGridParameter)
        {
            var usersQuery = _userManager.Users.AsNoTracking();
            if (jqGridParameter._search == "true")
            {
                usersQuery = usersQuery.Where(BuildWhere<ApplicationUser>(jqGridParameter.FilterObject, null));
            }

            var users = usersQuery.Include(u => u.UserRoles).ThenInclude(ur => ur.Role).OrderBy(u => u.InsertOrder)
                .Skip((jqGridParameter.Page - 1) * jqGridParameter.Rows).Take(jqGridParameter.Rows).ToList();
            var userCount = usersQuery.Count();
            var pageCount = Ceiling((double) userCount / jqGridParameter.Rows);
            return new JsonResult(
                new
                {
                    rows //數據集合
                        = users.Select(u => new
                        {
                            u.UserName,
                            u.Gender,
                            u.Email,
                            u.PhoneNumber,
                            u.EmailConfirmed,
                            u.PhoneNumberConfirmed,
                            u.CreationTime,
                            u.CreatorId,
                            u.Active,
                            u.LastModificationTime,
                            u.LastModifierId,
                            u.InsertOrder,
                            u.ConcurrencyStamp,
                            //以下為JqGrid中必須的字段
                            u.Id //記錄的唯一標識，可在插件中配置為其它字段，但是必須能作為記錄的唯一標識用，不能重復
                        }),
                    total = pageCount, //總頁數
                    page = jqGridParameter.Page, //當前頁碼
                    records = userCount //總記錄數
                }
            );
        }

       啟動項目后訪問 /Identity/Manage/Users/Index 可以嘗試使用。

結語

       通過這次實踐，深入了解了很多表達式樹的相關知識，表達式樹在編譯流程中還算是高級結構了，耐點心還是能看懂，IL 才是真的暈，比原生匯編也好不到哪里去。C# 確實很有意思，入門簡單，內部卻深邃無比，在小白和大神手上完全是兩種語言。Java 在 Java 8 時增加了 Stream 和 Lambda 表達式功能，一看就是在對標 Linq，不過那名字取的真是一言難盡，看代碼寫代碼感覺如鯁在喉，相當不爽。由於 Stream 體系缺少表達式樹，這種動態構造查詢表達式的功能從一開始就不可能支持。再加上 Java 沒有匿名類型，沒有對象初始化器，每次用 Stream 就難受的一批，中間過程的數據結構也要專門寫類，每個中間類還要獨占一個文件，簡直暈死。抄都抄不及格！

       C# 引入 var 關鍵字核心是為匿名類型服務，畢竟是編譯器自動生成的類型，寫代碼的時候根本沒有名字，不用 var 用什么？簡化變量初始化代碼只是順帶的。結果 Java 又抄一半，還是最不打緊的一半，簡化變量初始化代碼。真不知道搞 Java 的那幫人在想些什么。

 

       轉載請完整保留以下內容並在顯眼位置標注，未經授權刪除以下內容進行轉載盜用的，保留追究法律責任的權利！

　　本文地址：https://www.cnblogs.com/coredx/p/12423929.html

　　完整源代碼：Github

　　里面有各種小東西，這只是其中之一，不嫌棄的話可以Star一下。