.NET 6 WPF应用中LambdaExpression.Compile()的高效替代方案

针对你遇到的DynamicExpressionParser.ParseLambda编译耗时过长导致启动慢的问题，以下是几个性能更优的替代方案：

1. 缓存已编译的委托 #

如果存在重复的用户表达式，无需每次都重新编译，用字典缓存编译后的委托，后续直接复用：

private static readonly Dictionary<string, Func<double, bool>> _compiledExpressions = new(StringComparer.Ordinal);

public Func<double, bool> CreateDelegate(string expressionText)
{
    // 先检查缓存，存在则直接返回
    if (_compiledExpressions.TryGetValue(expressionText, out var cachedFunc))
    {
        return cachedFunc;
    }

    // 缓存不存在时编译并存入字典
    var xParam = Expression.Parameter(typeof(double), "x");
    var lambda = DynamicExpressionParser.ParseLambda(new[] { xParam }, null, expressionText);
    var compiledFunc = (Func<double, bool>)lambda.Compile();
    
    _compiledExpressions[expressionText] = compiledFunc;
    return compiledFunc;
}

这个方案能大幅减少重复表达式的编译次数，若用户定义的函数有重复，启动时间会显著降低。

2. 手写轻量表达式解析器（针对限定场景） #

你的表达式仅包含x与数值的比较（</>/<=/>=/==/!=）和逻辑与&&，无需通用表达式解析器的复杂逻辑。自己实现一个轻量解析器直接生成表达式树，性能远高于DynamicExpressionParser：

public Func<double, bool> CreateSimpleDelegate(string expressionText)
{
    var xParam = Expression.Parameter(typeof(double), "x");
    Expression finalExpression = Expression.Constant(true);

    // 拆分所有&&连接的条件
    var conditions = expressionText.Split(new[] { "&&" }, StringSplitOptions.RemoveEmptyEntries)
                                   .Select(c => c.Trim());

    foreach (var condition in conditions)
    {
        // 识别比较运算符
        var supportedOps = new[] { ">=", "<=", ">", "<", "==", "!=" };
        var op = supportedOps.FirstOrDefault(o => condition.Contains(o));
        if (op == null)
            throw new ArgumentException($"无效的条件表达式: {condition}");

        // 拆分x和目标数值
        var parts = condition.Split(new[] { op }, StringSplitOptions.RemoveEmptyEntries)
                             .Select(p => p.Trim())
                             .ToArray();
        if (parts.Length != 2 || parts[0] != "x")
            throw new ArgumentException($"条件格式错误: {condition}");

        if (!double.TryParse(parts[1], out var targetValue))
            throw new ArgumentException($"无效的数值: {parts[1]}");

        // 创建对应比较表达式
        Expression comparison = op switch
        {
            ">" => Expression.GreaterThan(xParam, Expression.Constant(targetValue)),
            "<" => Expression.LessThan(xParam, Expression.Constant(targetValue)),
            ">=" => Expression.GreaterThanOrEqual(xParam, Expression.Constant(targetValue)),
            "<=" => Expression.LessThanOrEqual(xParam, Expression.Constant(targetValue)),
            "==" => Expression.Equal(xParam, Expression.Constant(targetValue)),
            "!=" => Expression.NotEqual(xParam, Expression.Constant(targetValue)),
            _ => throw new ArgumentException($"不支持的运算符: {op}")
        };

        // 用逻辑与组合所有条件
        finalExpression = Expression.AndAlso(finalExpression, comparison);
    }

    var lambda = Expression.Lambda<Func<double, bool>>(finalExpression, xParam);
    return lambda.Compile();
}

这个方案仅处理你的特定场景，解析和编译速度比通用解析器快数倍，完全规避DynamicExpressionParser的额外开销。

3. 提前序列化编译后的委托（适合静态配置场景） #

如果用户定义的表达式不会频繁变更，可在首次编译后将委托序列化保存到本地文件，启动时直接反序列化加载，避免重复编译：

// 首次编译并保存
public void SaveCompiledDelegate(string expressionText, string filePath)
{
    var func = CreateDelegate(expressionText);
    // 注意：BinaryFormatter已标记为不安全，仅用于示例，实际推荐使用安全序列化方式（如表达式树转JSON）
    using var stream = new FileStream(filePath, FileMode.Create);
    var formatter = new BinaryFormatter();
    formatter.Serialize(stream, func);
}

// 启动时加载
public Func<double, bool> LoadCompiledDelegate(string filePath)
{
    using var stream = new FileStream(filePath, FileMode.Open);
    var formatter = new BinaryFormatter();
    return (Func<double, bool>)formatter.Deserialize(stream);
}

实际使用时建议替换BinaryFormatter为更安全的序列化方案，比如将表达式树结构转换为JSON格式保存，启动时重新构建表达式树并编译。

内容的提问来源于stack exchange，提问作者Andrew Stephens