EF Core中如何按多列匹配输入列表整行查询数据库

需求说明 #

输入为包含5个属性的MyClassDto列表，需要从数据库查询MyClassDb实体，要求实体行与输入列表中的某一行完全匹配（5个属性一一对应相等）。

当前错误写法 #

DTO定义 #

class MyClassDto
{
   public string Value1 { get; set; }
   public string Value2 { get; set; }
   public string Value3 { get; set; }
   public int Value4 { get; set; }
   public int Value5 { get; set; }
}

数据库实体MyClassDb包含完全相同的5个属性。

错误查询代码 #

public IEnumerable<MyClassDb> GetData(IEnumerable<MyClassDto> data)
{
    _context.MyClassDb.Where(x => data.Contains(x.Value1) && data.Contains(x.Value2) && ...
}

错误原因：该写法会返回输入数据中任意属性组合的匹配结果，而非整行所有属性完全匹配的记录。

可行解决方案 #

方案一：匿名类型组合匹配（EF Core 3.1+ 支持） #

将Dto的5个属性打包成匿名类型，通过Any方法匹配实体对应的属性组合是否存在于Dto集合中，确保整行匹配：

public IEnumerable<MyClassDb> GetData(IEnumerable<MyClassDto> data)
{
    var dtoTuples = data.Select(d => new { d.Value1, d.Value2, d.Value3, d.Value4, d.Value5 });
    return _context.MyClassDb.Where(db => 
        dtoTuples.Any(dto => 
            db.Value1 == dto.Value1 && 
            db.Value2 == dto.Value2 && 
            db.Value3 == dto.Value3 && 
            db.Value4 == dto.Value4 && 
            db.Value5 == dto.Value5));
}

EF Core会自动将该逻辑转换为对应的SQL EXISTS或IN子句，保证只有整行属性完全匹配的实体才会被返回。

方案二：安全构建表达式树（避免栈溢出） #

手动构建表达式树时出现栈溢出，通常是递归逻辑不当导致。可以通过循环逐步构建条件，避免嵌套过深：

using System.Linq.Expressions;

public IEnumerable<MyClassDb> GetData(IEnumerable<MyClassDto> data)
{
    var dtos = data.ToList();
    if (!dtos.Any())
        return Enumerable.Empty<MyClassDb>();

    ParameterExpression param = Expression.Parameter(typeof(MyClassDb), "db");
    // 初始化第一个Dto的匹配条件
    Expression predicate = BuildSingleDtoMatchExpression(param, dtos[0]);

    // 循环添加后续Dto的匹配条件，用OrElse组合
    for (int i = 1; i < dtos.Count; i++)
    {
        var currentExpr = BuildSingleDtoMatchExpression(param, dtos[i]);
        predicate = Expression.OrElse(predicate, currentExpr);
    }

    var query = _context.MyClassDb.Where(Expression.Lambda<Func<MyClassDb, bool>>(predicate, param));
    return query.ToList();
}

// 辅助方法：构建单个Dto与实体的全属性匹配表达式
private Expression BuildSingleDtoMatchExpression(ParameterExpression param, MyClassDto dto)
{
    var value1Match = Expression.Equal(Expression.Property(param, nameof(MyClassDb.Value1)), Expression.Constant(dto.Value1));
    var value2Match = Expression.Equal(Expression.Property(param, nameof(MyClassDb.Value2)), Expression.Constant(dto.Value2));
    var value3Match = Expression.Equal(Expression.Property(param, nameof(MyClassDb.Value3)), Expression.Constant(dto.Value3));
    var value4Match = Expression.Equal(Expression.Property(param, nameof(MyClassDb.Value4)), Expression.Constant(dto.Value4));
    var value5Match = Expression.Equal(Expression.Property(param, nameof(MyClassDb.Value5)), Expression.Constant(dto.Value5));

    // 组合所有属性的相等条件
    return Expression.AndAlso(
        Expression.AndAlso(value1Match, value2Match),
        Expression.AndAlso(
            Expression.AndAlso(value3Match, value4Match),
            value5Match));
}

该方式通过循环而非递归构建表达式，避免栈溢出，最终生成的逻辑是：实体匹配输入列表中任意一个Dto的全属性组合。

注意事项 #

• 若输入Dto列表过大（如千条以上），需注意SQL查询性能，可考虑分批查询或使用临时表优化。
• 确保MyClassDb与MyClassDto的对应属性类型完全一致，避免类型转换错误。

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