DataTable dt = new DataTable();
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Age", typeof(int));
dt.Rows.Add(1, "张三", 25);
dt.Rows.Add(2, "李四", 30);
dt.Rows.Add(3, "王五", 28);

List<User> users = new List<User>
{
    new User { Id = 1, Name = "张三", Age = 25 },
    new User { Id = 2, Name = "李四", Age = 30 }
};

Dictionary<string, string> dict = new Dictionary<string, string>();
dict.Add("name", "张三");
dict.Add("city", "北京");
dict.Add("job", "工程师");

// C# 中查询数据库
DataTable dt = ExecuteQuery("SELECT * FROM Users WHERE Age > 25");

// 在调试窗口中输入 dt，查看查询结果

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Insurance.Api.Model.Models.Labour;

namespace Insurance.Application.Helpers
{
    /// <summary>
    /// LabourRecord 查询辅助类
    /// 用于处理 JsonResult 中的数据查询和日期比较
    /// </summary>
    public static class LabourRecordQueryHelper
    {
        /// <summary>
        /// 查询条件委托
        /// </summary>
        public delegate bool QueryCondition(Dictionary<string, string> jsonData);

        /// <summary>
        /// 创建简单的相等条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="value">值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateEqualCondition(string fieldName, string value)
        {
            return (jsonData) => jsonData.GetFieldValue(fieldName) == value;
        }

        /// <summary>
        /// 创建简单的相等条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="value">值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateNotEqualCondition(string fieldName, string value)
        {
            return (jsonData) => jsonData.GetFieldValue(fieldName) != value;
        }

        /// <summary>
        /// 创建日期大于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateGreaterThanCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateGreaterThan(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期小于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateLessThanCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateLessThan(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期等于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateEqualCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateEqual(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期大于等于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateGreaterThanOrEqualCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateGreaterThanOrEqual(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建日期小于等于条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="dateValue">日期值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateDateLessThanOrEqualCondition(string fieldName, string dateValue)
        {
            return (jsonData) => IsDateLessThanOrEqual(jsonData.GetFieldValue(fieldName), dateValue);
        }

        /// <summary>
        /// 创建字段 IndexOf 条件
        /// 如：P11.IndexOf("12") > -1 表示 P11 包含 "12"
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="searchValue">要查找的值</param>
        /// <param name="compareValue">比较值（通常是 -1 用于检查是否包含）</param>
        /// <param name="comparison">比较类型：>, <, ==, !=, >=, <=</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateIndexOfCondition(
            string fieldName,
            string searchValue,
            int compareValue,
            string comparison = ">")
        {
            return (jsonData) =>
            {
                var fieldValue = jsonData.GetFieldValue(fieldName);
                if (string.IsNullOrEmpty(fieldValue))
                {
                    return false;
                }

                var indexOfResult = fieldValue.IndexOf(searchValue, StringComparison.Ordinal);

                return comparison switch
                {
                    ">" => indexOfResult > compareValue,
                    "<" => indexOfResult < compareValue,
                    "==" => indexOfResult == compareValue,
                    "!=" => indexOfResult != compareValue,
                    ">=" => indexOfResult >= compareValue,
                    "<=" => indexOfResult <= compareValue,
                    _ => throw new ArgumentException($"不支持的比较类型: {comparison}")
                };
            };
        }

        /// <summary>
        /// 创建字段包含检查条件（简化的 IndexOf > -1）
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="searchValue">要查找的值</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateContainsCondition(string fieldName, string searchValue)
        {
            return CreateIndexOfCondition(fieldName, searchValue, -1, ">");
        }

        /// <summary>
        /// 创建常量字符串 IndexOf 条件
        /// 如："12".IndexOf(S15) > -1 表示 "12" 包含 S15 的值
        /// </summary>
        /// <param name="constantString">常量字符串</param>
        /// <param name="fieldName">字段名</param>
        /// <param name="compareValue">比较值（通常是 -1 用于检查是否包含）</param>
        /// <param name="comparison">比较类型：>, <, ==, !=, >=, <=</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateConstantIndexOfCondition(
            string constantString,
            string fieldName,
            int compareValue,
            string comparison = ">")
        {
            return (jsonData) =>
            {
                var fieldValue = jsonData.GetFieldValue(fieldName);
                if (string.IsNullOrEmpty(fieldValue))
                {
                    return false;
                }

                var indexOfResult = constantString.IndexOf(fieldValue, StringComparison.Ordinal);

                return comparison switch
                {
                    ">" => indexOfResult > compareValue,
                    "<" => indexOfResult < compareValue,
                    "==" => indexOfResult == compareValue,
                    "!=" => indexOfResult != compareValue,
                    ">=" => indexOfResult >= compareValue,
                    "<=" => indexOfResult <= compareValue,
                    _ => throw new ArgumentException($"不支持的比较类型: {comparison}")
                };
            };
        }

        /// <summary>
        /// 创建常量字符串包含字段值检查条件（简化的常量 IndexOf > -1）
        /// </summary>
        /// <param name="constantString">常量字符串</param>
        /// <param name="fieldName">字段名</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateConstantContainsCondition(string constantString, string fieldName)
        {
            return CreateConstantIndexOfCondition(constantString, fieldName, -1, ">");
        }

        /// <summary>
        /// 创建字段 SubString 条件
        /// </summary>
        /// <param name="fieldName">字段名</param>
        /// <param name="start">起始位置</param>
        /// <param name="length">长度</param>
        /// <param name="compareValue">比较值</param>
        /// <param name="comparison">比较类型：==, !=</param>
        /// <returns>查询条件</returns>
        public static QueryCondition CreateSubStringCondition(
            string fieldName,
            int start,
            int length,
            string compareValue,
            string comparison = "==")
        {
            return (jsonData) =>
            {
                var fieldValue = jsonData.GetFieldValue(fieldName);
                if (string.IsNullOrEmpty(fieldValue) || fieldValue.Length < start + length)
                {
                    return false;
                }

                var subString = fieldValue.Substring(start, length);

                return comparison switch
                {
                    "==" => subString == compareValue,
                    "!=" => subString != compareValue,
                    _ => throw new ArgumentException($"SubString 只支持 == 或 != 比较")
                };
            };
        }

        /// <summary>
        /// 组合多个条件（AND）
        /// </summary>
        /// <param name="conditions">条件数组</param>
        /// <returns>组合后的查询条件</returns>
        public static QueryCondition CombineAnd(params QueryCondition[] conditions)
        {
            return (jsonData) => conditions.All(condition => condition(jsonData));
        }

        /// <summary>
        /// 组合多个条件（OR）
        /// </summary>
        /// <param name="conditions">条件数组</param>
        /// <returns>组合后的查询条件</returns>
        public static QueryCondition CombineOr(params QueryCondition[] conditions)
        {
            return (jsonData) => conditions.Any(condition => condition(jsonData));
        }
    }
}

public LabourRecordQueryHelper.QueryCondition GetQueryCondition(
        string startDate,
        string endDate)
    {
        // 实现你的查询条件逻辑
        var condition1 = LabourRecordQueryHelper.CreateEqualCondition("S15", "1");
        var condition2 = LabourRecordQueryHelper.CreateSubStringCondition("P11", 0, 2, "00", "!=");
        var conditionResult1 = LabourRecordQueryHelper.CombineAnd(condition1, condition2);

        LabourRecordQueryHelper.QueryCondition condition3 = LabourRecordQueryHelper.CreateNotEqualCondition("G62", "是");
        LabourRecordQueryHelper.QueryCondition condition4 = LabourRecordQueryHelper.CreateNotEqualCondition("G62", "T");
        var conditionResult2 = LabourRecordQueryHelper.CombineAnd(condition3, condition4);

        return LabourRecordQueryHelper.CombineAnd(conditionResult1, conditionResult2);
    }

Math.Round(value, 保留小数位数, MidpointRounding.AwayFromZero)

value >= 0 ? Math.Ceiling(value * (decimal)Math.Pow(10, 保留小数位数)) / (decimal)Math.Pow(10, 保留小数位数) : Math.Floor(value * (decimal)Math.Pow(10, 保留小数位数)) / (decimal)Math.Pow(10, 保留小数位数);

value >= 0 ? Math.Floor(value * (decimal)Math.Pow(10, 保留小数位数)) / (decimal)Math.Pow(10, 保留小数位数) : Math.Ceiling(value * (decimal)Math.Pow(10, 保留小数位数)) / (decimal)Math.Pow(10, 保留小数位数)

using Newtonsoft.Json.Linq;

if (args.Length < 3)
{
    Console.WriteLine("Usage: ConfigMerger <outputFile> <baseConfig> <overrideConfig>");
    return 1;
}

try
{
    // e.g /Users/odinsam/gitee/zb/xxx/serverPublish/appsettings.json
    var outputFile = args[0];
    // e.g /Users/odinsam/gitee/zb/xxx/serverPublish/appsettings.json
    var baseConfig = args[1];
    // e.g /Users/odinsam/gitee/zb/xxx/serverPublish/appsettings.Development.xxx.json
    var overrideConfig = args[2];

    // 读取基础配置
    var baseJson = File.Exists(baseConfig)
        ? JObject.Parse(File.ReadAllText(baseConfig))
        : new JObject();

    // 读取覆盖配置
    if (File.Exists(overrideConfig))
    {
        var overrideJson = JObject.Parse(File.ReadAllText(overrideConfig))!;
        MergeJsonObjects(baseJson, overrideJson);
    }

    // 写入合并后的文件
    Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
    File.WriteAllText(outputFile, baseJson.ToString(Newtonsoft.Json.Formatting.Indented));

    return 0;
}
catch (Exception ex)
{
    Console.WriteLine($"Error merging configs: {ex.Message}");
    return 1;
}

static void MergeJsonObjects(JObject target, JObject source)
{
    foreach (var property in source.Properties())
    {
        if (property.Value is JObject sourceObj &&
            target.TryGetValue(property.Name, out var targetValue) &&
            targetValue is JObject targetObj)
        {
            MergeJsonObjects(targetObj, sourceObj);
        }
        else
        {
            target[property.Name] = property.Value?.DeepClone();
        }
    }
}

public class JsonQueryBuilder
{
    /// <summary>
    /// 应用JSON条件到查询
    /// </summary>
    public static ISugarQueryable<LabourRecord, MDMUser, MDMOrganization> ApplyJsonConditions(
        ISugarQueryable<LabourRecord, MDMUser, MDMOrganization> query,
        string userCondition,
        List<MongoLabourDbColumnInfo> dBColumns)
    {
        if (string.IsNullOrWhiteSpace(userCondition) || userCondition.Trim() == "1==1" || userCondition.Trim() == "(1==1)")
        {
            return query;
        }

        var conditions = ParseConditions(userCondition);

        for (int i = 0; i < conditions.Count; i++)
        {
            query = ApplyCondition(query, conditions[i], i, dBColumns);
        }

        return query;
    }

    private static ISugarQueryable<LabourRecord, MDMUser, MDMOrganization> ApplyCondition(
        ISugarQueryable<LabourRecord, MDMUser, MDMOrganization> query,
        JsonQueryCondition condition,
        int conditionIndex,
        List<MongoLabourDbColumnInfo> dBColumns)
    {
        var isNotContains = false;
        string jsonAccess = $"JSON_VALUE(CAST(JsonResult AS NVARCHAR(MAX)), '$.{condition.Field}')";
        if (jsonAccess.Contains("$.!"))
        {
            isNotContains = true;
            jsonAccess = jsonAccess.Replace("$.!", "$.");
        }
        string paramName = $"val{conditionIndex}";  // 唯一参数名
        string filed = condition.Field;
        filed = filed.StartsWith("!") ? filed.Substring(1) : filed;
        var currentColumn = dBColumns.SingleOrDefault(c => c.ColumnCode == filed);

        var whereString = string.Empty;
        var value = condition.Value;
        value = value.Replace("\"", "");
        var op = condition.Field.StartsWith("!") && condition.Operator == "Contains"
        ? "!Contains"
        : condition.Operator;
        if (op == "==")
        {
            op = "=";
        }

        whereString = $"{jsonAccess} {op} @{paramName}";

        object objectParams = null;
        if (currentColumn.DataType.StartsWith("decimal"))
        {
            objectParams = new Dictionary<string, object> { [paramName] = Convert.ToInt32(value) };
        }
        else
        {
            objectParams = new Dictionary<string, string> { [paramName] = value };
        }

        switch (op)
        {
            case "=":
            case "!=":
            case ">":
            case "<":
            case ">=":
            case "<=":
                return query.Where(whereString, objectParams);
            case "Contains":
                return query.Where($"{jsonAccess} LIKE @{paramName}",
                    new Dictionary<string, object> { [paramName] = $"%{value}%" });

            case "!Contains":
                // 处理否定包含条件
                return query.Where($"({jsonAccess} IS NULL OR {jsonAccess} NOT LIKE @{paramName})",
                    new Dictionary<string, object> { [paramName] = $"%{value}%" });

            default:
                throw new ArgumentException($"不支持的运算符: {condition.Operator}");
        }
    }

    /// <summary>
    /// 解析条件字符串为条件对象列表
    /// </summary>
    private static List<JsonQueryCondition> ParseConditions(string conditionStr)
    {
        var conditions = new List<JsonQueryCondition>();

        // 分割条件，忽略空条件和1==1
        var andGroups = conditionStr.Split(new[] { "&&" }, StringSplitOptions.RemoveEmptyEntries)
            .ToList()
            .Where(cond => cond.Trim() != "1==1")
            .Where(cond => !string.IsNullOrWhiteSpace(cond))
            .ToList();

        foreach (var group in andGroups)
        {
            var trimmed = group.Trim();
            if (string.IsNullOrWhiteSpace(trimmed)) continue;

            var condition = new JsonQueryCondition();

            // 处理 Contains
            if (trimmed.Contains(".Contains("))
            {
                condition.Field = trimmed.Substring(0, trimmed.IndexOf('.')).Trim();
                condition.Operator = "Contains";
                condition.Value = GetStringBetweenQuotes(trimmed);
            }
            // 处理 ==
            else if (trimmed.Contains("=="))
            {
                var parts = trimmed.Split(new[] { "==" }, StringSplitOptions.RemoveEmptyEntries);
                condition.Field = parts[0].Trim();
                condition.Operator = "==";
                condition.Value = parts[1].Trim().Trim('"');
            }
            // 处理 !=
            else if (trimmed.Contains("!="))
            {
                var parts = trimmed.Split(new[] { "!=" }, StringSplitOptions.RemoveEmptyEntries);
                condition.Field = parts[0].Trim();
                condition.Operator = "!=";
                condition.Value = parts[1].Trim().Trim('"');
            }
            // 处理 >
            else if (trimmed.Contains(">"))
            {
                var parts = trimmed.Split('>');
                condition.Field = parts[0].Trim();
                condition.Operator = ">";
                condition.Value = parts[1].Trim();
            }
            // 处理 <
            else if (trimmed.Contains("<"))
            {
                var parts = trimmed.Split('<');
                condition.Field = parts[0].Trim();
                condition.Operator = "<";
                condition.Value = parts[1].Trim();
            }
            // 处理 >=
            else if (trimmed.Contains(">="))
            {
                var parts = trimmed.Split(new[] { ">=" }, StringSplitOptions.RemoveEmptyEntries);
                condition.Field = parts[0].Trim();
                condition.Operator = ">=";
                condition.Value = parts[1].Trim();
            }
            // 处理 <=
            else if (trimmed.Contains("<="))
            {
                var parts = trimmed.Split(new[] { "<=" }, StringSplitOptions.RemoveEmptyEntries);
                condition.Field = parts[0].Trim();
                condition.Operator = "<=";
                condition.Value = parts[1].Trim();
            }
            else
            {
                throw new ArgumentException($"无法识别的条件格式: {trimmed}");
            }

            conditions.Add(condition);
        }

        return conditions;
    }

    /// <summary>
    /// 获取引号之间的字符串
    /// </summary>
    private static string GetStringBetweenQuotes(string input)
    {
        int firstQuote = input.IndexOf('"');
        if (firstQuote == -1) return string.Empty;

        int secondQuote = input.IndexOf('"', firstQuote + 1);
        if (secondQuote == -1) return string.Empty;

        return input.Substring(firstQuote + 1, secondQuote - firstQuote - 1);
    }

}

var selectQuery = this._dbContext.Insurance.Queryable<LabourRecord>()
                    .InnerJoin<MDMUser>((lr, usr) => lr.UserID == usr.ID)
                    .InnerJoin<MDMOrganization>((lr, usr, org) => lr.DeptID == org.ID)
                    .AS($"Labour_Record_{dbCode}")
                    .Where((lr, usr, org) =>
                        lr.Status == 1 && usr.Status == 1 && org.Status == 1
                    );
if (!string.IsNullOrEmpty(search.entity.Filter) && search.entity.Filter != "(1==1)")
            {
                var condation = search.entity.Filter;
                // 去掉引号 可忽略
                condation = string.IsNullOrEmpty(condation) ? "1==1" : condation.Substring(1, condation.Length - 2);
                selectQuery = JsonQueryBuilder.ApplyJsonConditions(selectQuery, condation, dbColumns);
                System.Console.WriteLine(selectQuery.ToSqlString());
                return selectQuery;
            }
            else
            {
                return selectQuery;
            }

/// <summary>
/// 通用的查询方法，支持单表查询和多表联查
/// </summary>
/// <typeparam name="TResult">返回的 DTO 类型</typeparam>
/// <param name="selectExpression">选择字段表达式</param>
/// <param name="joinExpression">联表表达式（可为空）</param>
/// <param name="whereExpressions">查询条件表达式集合（可为空）</param>
/// <param name="whereIfExpressions">动态条件表达式集合（可为空）</param>
/// <param name="orderExpressions">多排序表达式集合（可为空）</param>
/// <param name="tableName">查询主表的表名（可为空）</param>
/// <returns></returns>
public List<TResult> Query<TResult>(
    Expression<Func<TEntity, TResult>> selectExpression,
    Func<ISugarQueryable<TEntity>, ISugarQueryable<TEntity>>? joinExpression=null,
    List<Expression<Func<TEntity, bool>>>? whereExpressions = null,
    List<WhereIfExpression<TEntity>>? whereIfExpressions = null,
    List<OrderExpression<TEntity>>? orderExpressions = null,
    string? tableName = null)
{
    var query = string.IsNullOrEmpty(tableName)
        ? _db.Queryable<TEntity>()
        : _db.Queryable<TEntity>().AS(tableName);

    // 联表
    if (joinExpression != null)
    {
        query = joinExpression(query);
    }

    // 查询条件
    if (whereExpressions != null)
    {
        query = whereExpressions.Aggregate(
            query, 
            (current, whereExpression) => 
                current.Where(whereExpression));
    }

    if (whereIfExpressions != null)
    {
        query = whereIfExpressions.Aggregate(
            query, 
            (current, whereIfExpression) => 
                current.WhereIF(whereIfExpression.IsWhere, whereIfExpression.WhereIf));
    }
    
    // 排序条件
    if (orderExpressions != null)
    {
        query = orderExpressions.Aggregate(
            query, 
            (current, orderExpression) => 
                current.OrderBy(orderExpression.Order, orderExpression.OrderType));
    }

    // 选择字段
    return query.Select(selectExpression).ToList();
}

/// <summary>
/// 通用的查询方法，支持单表查询和多表联查
/// </summary>
/// <typeparam name="TResult">返回的 DTO 类型</typeparam>
/// <param name="pageQueryResponse">分页查询返回对象</param>
/// <param name="selectExpression">选择字段表达式</param>
/// <param name="primaryKeyExpression">选择字段表达式</param>
/// <param name="joinExpression">联表表达式（可为空）</param>
/// <param name="whereExpressions">查询条件表达式集合（可为空）</param>
/// <param name="whereIfExpressions">动态条件表达式集合（可为空）</param>
/// <param name="orderExpressions">多排序表达式集合（可为空）</param>
/// <param name="tableName">查询主表的表名（可为空）</param>
/// <param name="pageIndex">查询第几页（可为空,默认第一页）</param>
/// <param name="pageSize">查询每页大小（可为空,默认一页10条记录）</param>
/// <returns></returns>
public PageQueryResponse<TResult> QueryPageing<TResult>(
    PageQueryResponse<TResult> pageQueryResponse,
    Expression<Func<TEntity, TResult>> selectExpression,
    Expression<Func<TEntity,TKey>> primaryKeyExpression,
    Func<ISugarQueryable<TEntity>, ISugarQueryable<TEntity>>? joinExpression=null,
    List<Expression<Func<TEntity, bool>>>? whereExpressions = null,
    List<WhereIfExpression<TEntity>>? whereIfExpressions = null,
    List<OrderExpression<TEntity>>? orderExpressions = null,
    string? tableName = null,
    int pageIndex = 0,
    int pageSize = 10)
{
    var query = string.IsNullOrEmpty(tableName)
        ? _db.Queryable<TEntity>()
        : _db.Queryable<TEntity>().AS(tableName);

    // 联表
    if (joinExpression != null)
    {
        query = joinExpression(query);
    }

    // 查询条件
    if (whereExpressions != null)
    {
        query = whereExpressions.Aggregate(
            query, 
            (current, whereExpression) => 
                current.Where(whereExpression));
    }

    if (whereIfExpressions != null)
    {
        query = whereIfExpressions.Aggregate(
            query, 
            (current, whereIfExpression) => 
                current.WhereIF(whereIfExpression.IsWhere, whereIfExpression.WhereIf));
    }
    
    // 排序条件
    if (orderExpressions != null)
    {
        query = orderExpressions.Aggregate(
            query, 
            (current, orderExpression) => 
                current.OrderBy(orderExpression.Order, orderExpression.OrderType));
    }

    
    var totalNumber = 0;
    var primaryKeys = query
        .Select(primaryKeyExpression)
        .ToPageList(pageQueryResponse.PageNumber,pageQueryResponse.PageSize,ref totalNumber);
    
    pageQueryResponse.TotalNumber = totalNumber;
    
    var pagedQuery =string.IsNullOrEmpty(tableName)
        ? _db.Queryable<TEntity>().Where(p => primaryKeys!.Contains(p.Id))
        : _db.Queryable<TEntity>().AS(tableName).Where(p => primaryKeys!.Contains(p.Id));
    
    // 联表（如果传入联表表达式）
    if (joinExpression != null)
    {
        pagedQuery = joinExpression(pagedQuery);
    }

    // 选择字段（如果传入选择字段表达式）
    pageQueryResponse.Data = pagedQuery.Select(selectExpression).ToList();
    
    // 选择字段
    return pageQueryResponse;
}

var userGDAA = (from gdaa in allGDAADatas
    where gdaa.UserID == currentUserId
    let recordDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(gdaa.JsonResult)
    orderby recordDic["S18"]
    select gdaa).ToList();

var userGDAA = allGDAADatas
    .Where(gdaa => gdaa.UserID == currentUserId)
    .Select(gdaa => new 
    { 
        Gdaa = gdaa, 
        RecordDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(gdaa.JsonResult) 
    })
    .OrderBy(x => x.RecordDic["S18"])
    .Select(x => x.Gdaa)
    .ToList();