如何在Linq to SQL中使用子函数实现查询过滤？

在Linq to SQL中，复杂的WHERE查询条件难以维护，希望将拆分后的条件逻辑封装成具名函数（如HasCondition1、HasCondition2）来提升可读性，但直接调用子函数会导致查询无法转换为SQL。

原Linq to SQL查询代码：

query = query.Where(
    f => f.Table1.Any(
        t1 =>
            (t1.Table2.Any(t2 => t2.Header == Decoder.Identifier
                && DbFunctions.Like(t2.Content, pattern)))
            ||
            (!t1.Table2.Any(t2 => t2.Header == Decoder.Identifier)
                && DbFunctions.Like(t1.Text, pattern))
        ));

期望的语义化写法：

query = query.Where(
    f => f.Table1.Any(
        t1 =>
            HasCondition1(t1, pattern)
            ||
            HasCondition2(t1, pattern)
        ));

1. 结合LinqKit与表达式树（推荐） #

Linq to SQL支持解析表达式树，我们可以将条件逻辑封装为返回Expression<Func<...>>的方法，再通过LinqKit的AsExpandable()和Invoke()方法让Linq to SQL正确解析。

步骤： #

1. 安装LinqKit NuGet包
2. 定义条件表达式方法：

private static Expression<Func<T1, string, bool>> HasCondition1()
{
    return (t1, pattern) => 
        t1.Table2.Any(t2 => t2.Header == Decoder.Identifier 
            && DbFunctions.Like(t2.Content, pattern));
}

private static Expression<Func<T1, string, bool>> HasCondition2()
{
    return (t1, pattern) => 
        !t1.Table2.Any(t2 => t2.Header == Decoder.Identifier) 
            && DbFunctions.Like(t1.Text, pattern);
}

3. 在查询中使用：

query = query.AsExpandable().Where(
    f => f.Table1.Any(
        t1 => HasCondition1().Invoke(t1, pattern) 
            || HasCondition2().Invoke(t1, pattern)
    ));

2. 封装为返回表达式的扩展方法 #

如果不想引入第三方库，可以直接将条件封装成返回表达式的扩展方法，直接用于Any查询：

public static class T1ConditionExtensions
{
    public static Expression<Func<T1, bool>> HasCondition1(string pattern)
    {
        return t1 => t1.Table2.Any(t2 => t2.Header == Decoder.Identifier 
            && DbFunctions.Like(t2.Content, pattern));
    }

    public static Expression<Func<T1, bool>> HasCondition2(string pattern)
    {
        return t1 => !t1.Table2.Any(t2 => t2.Header == Decoder.Identifier) 
            && DbFunctions.Like(t1.Text, pattern);
    }
}

// 使用方式
query = query.Where(f => f.Table1.Any(T1ConditionExtensions.HasCondition1(pattern)) 
                        || f.Table1.Any(T1ConditionExtensions.HasCondition2(pattern)));

3. 手动拼接表达式树（进阶） #

完全不依赖第三方库时，可以手动构建表达式树组合条件，适合对表达式树有一定了解的场景：

// 定义参数表达式
var t1Param = Expression.Parameter(typeof(T1), "t1");
var patternParam = Expression.Constant(pattern, typeof(string));

// 构建HasCondition1的表达式
var t2Param = Expression.Parameter(typeof(T2), "t2");
var condition1Body = Expression.AndAlso(
    Expression.Equal(Expression.Property(t2Param, nameof(T2.Header)), Expression.Constant(Decoder.Identifier)),
    Expression.Call(typeof(DbFunctions), nameof(DbFunctions.Like), null,
        Expression.Property(t2Param, nameof(T2.Content)), patternParam)
);
var condition1 = Expression.Lambda<Func<T2, bool>>(condition1Body, t2Param);
var hasCondition1 = Expression.Call(
    typeof(Enumerable), nameof(Enumerable.Any), new[] { typeof(T2) },
    Expression.Property(t1Param, nameof(T1.Table2)), condition1
);

// 同理构建HasCondition2的表达式
var noIdentifierInTable2 = Expression.Not(Expression.Call(
    typeof(Enumerable), nameof(Enumerable.Any), new[] { typeof(T2) },
    Expression.Property(t1Param, nameof(T1.Table2)),
    Expression.Lambda<Func<T2, bool>>(
        Expression.Equal(Expression.Property(t2Param, nameof(T2.Header)), Expression.Constant(Decoder.Identifier)),
        t2Param)
));
var condition2Body = Expression.AndAlso(
    noIdentifierInTable2,
    Expression.Call(typeof(DbFunctions), nameof(DbFunctions.Like), null,
        Expression.Property(t1Param, nameof(T1.Text)), patternParam)
);

// 组合最终条件并应用到查询
var combinedCondition = Expression.OrElse(hasCondition1, condition2Body);
var finalPredicate = Expression.Lambda<Func<T1, bool>>(combinedCondition, t1Param);
query = query.Where(f => f.Table1.Any(finalPredicate));

内容的提问来源于stack exchange，提问作者Dee J. Doena