Moq无法匹配Lambda表达式：如何正确配置GetCriteriaBy的Mock Setup？

原来的匹配失败核心原因是表达式树的结构不匹配：你手动编写的matchExpression中，未赋值字段是直接与null常量做比较，但业务代码生成的表达式是和request.Market这类请求对象的属性做比较（哪怕request.Market的值是null，表达式树的节点类型是成员访问，而非常量），所以Lambda.Equals会判定两个表达式不一致，导致匹配失效。

以下是两种可行的修正方案：

方案一：编译表达式验证逻辑（最简单直接） #

避开表达式树结构的差异，直接验证表达式的逻辑行为——将传入的表达式编译成可执行委托，用测试数据验证其是否符合预期：

// 构造符合预期条件的测试对象
var validCriteria = new Criteria
{
    IsActive = true,
    Crop = "Corn",
    Region = "NA",
    Market = null,
    ProductStage = null,
    Trait = null,
    HarvestType = null
};

// 构造不符合条件的测试对象，避免误匹配
var invalidCriteria = new Criteria
{
    IsActive = false,
    Crop = "Wheat",
    Region = "EU"
};

mock.Setup(cr => cr.GetCriteriaBy(It.Is<Expression<Func<Criteria, bool>>>(expr => 
{
    var evaluate = expr.Compile();
    // 验证：符合条件的对象返回true，不符合的返回false
    return evaluate(validCriteria) && !evaluate(invalidCriteria);
})))
.ReturnsAsync(new List<CriteriaResponse>
{
    new CriteriaResponse { Id = 1, Crop = "Corn", Region = "NA" }
});

这种方式只关注表达式的逻辑结果，完全绕过了表达式树结构差异的问题，简单高效，适合大多数测试场景。

方案二：自定义表达式树匹配器（精准匹配结构） #

如果需要严格匹配表达式树的结构，可以编写自定义方法解析表达式节点，逐一验证条件：

private bool IsExpectedExpression(Expression<Func<Criteria, bool>> expr)
{
    // 提取所有由AndAlso连接的相等条件
    var conditions = new List<BinaryExpression>();
    void ExtractConditions(Expression node)
    {
        if (node is BinaryExpression binExpr)
        {
            if (binExpr.NodeType == ExpressionType.AndAlso)
            {
                ExtractConditions(binExpr.Left);
                ExtractConditions(binExpr.Right);
            }
            else if (binExpr.NodeType == ExpressionType.Equal)
            {
                conditions.Add(binExpr);
            }
        }
    }

    ExtractConditions(expr.Body);

    // 验证关键条件
    bool hasValidIsActive = conditions.Any(c => 
        c.Left is MemberExpression left && left.Member.Name == nameof(Criteria.IsActive) &&
        c.Right is ConstantExpression right && (bool)right.Value == true);
    
    bool hasValidCrop = conditions.Any(c => 
        c.Left is MemberExpression left && left.Member.Name == nameof(Criteria.Crop) &&
        c.Right is MemberExpression right && right.Member.DeclaringType == typeof(CriteriaRequest) && right.Member.Name == nameof(CriteriaRequest.Crop));
    
    bool hasValidRegion = conditions.Any(c => 
        c.Left is MemberExpression left && left.Member.Name == nameof(Criteria.Region) &&
        c.Right is MemberExpression right && right.Member.DeclaringType == typeof(CriteriaRequest) && right.Member.Name == nameof(CriteriaRequest.Region));
    
    // 验证其他字段的匹配逻辑
    bool hasValidMarket = conditions.Any(c => 
        c.Left is MemberExpression left && left.Member.Name == nameof(Criteria.Market) &&
        (c.Right is MemberExpression right && right.Member.DeclaringType == typeof(CriteriaRequest) ||
         c.Right is ConstantExpression right && right.Value == null));

    // 同理添加ProductStage、Trait、HarvestType的检查...

    return hasValidIsActive && hasValidCrop && hasValidRegion && hasValidMarket;
}

// 使用自定义匹配器
mock.Setup(cr => cr.GetCriteriaBy(It.Is<Expression<Func<Criteria, bool>>>(expr => IsExpectedExpression(expr))))
.ReturnsAsync(new List<CriteriaResponse>
{
    new CriteriaResponse { Id = 1, Crop = "Corn", Region = "NA" }
});

这种方式精准匹配表达式树的结构，适合对匹配精度要求极高的场景，但需要处理表达式树的细节逻辑。

内容的提问来源于stack exchange，提问作者A. Hasemeyer