LINQ to SQL查询报错：姓名子串匹配无法使用Any的解决方案求助

嘿，这个问题我之前也踩过坑！LINQ to SQL没办法把本地集合的Any()+Contains()组合转换成对应的SQL语句，它只支持把本地集合用在Contains()作为数据库字段的匹配条件（也就是filterArr.Contains(u.Name)这种，但这显然满足不了你的子串匹配需求）。下面给你几个可行的解决方案：

方案1：用PredicateBuilder动态拼接OR条件（最推荐） #

这是最优雅且安全的方式，通过动态构建多个Name.Contains(xxx)的OR逻辑，让LINQ to SQL能正确转换成SQL语句。

首先你可以自己实现一个极简版的PredicateBuilder（不用额外引用库）：

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> True<T>() => _ => true;
    public static Expression<Func<T, bool>> False<T>() => _ => false;

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> left,
                                                Expression<Func<T, bool>> right)
    {
        var invokedRight = Expression.Invoke(right, left.Parameters.Cast<Expression>());
        return Expression.Lambda<Func<T, bool>>
              (Expression.OrElse(left.Body, invokedRight), left.Parameters);
    }
}

然后修改你的查询代码：

string filter = "alex, faheem, Cohen"; 
var filterArr = filter.Split(new []{','}, StringSplitOptions.RemoveEmptyEntries)
                      .Select(f => f.Trim())
                      .ToList(); 

// 初始化一个永远为false的谓词，后续拼接OR条件
var matchPredicate = PredicateBuilder.False<User>();
foreach (var nameFragment in filterArr)
{
    // 注意这里要临时变量存nameFragment，避免闭包陷阱
    var tempFragment = nameFragment;
    matchPredicate = matchPredicate.Or(u => u.Name.Contains(tempFragment));
}

var users = DbContext.Users.Where(matchPredicate);

这样最终生成的SQL会是类似WHERE Name LIKE '%alex%' OR Name LIKE '%faheem%' OR Name LIKE '%Cohen%'的语句，完美实现你要的子串匹配，而且完全符合LINQ的写法，没有注入风险。

方案2：手动构造参数化SQL（适合老项目或特殊场景） #

如果你不想用PredicateBuilder，也可以直接写SQL，但一定要做参数化处理，绝对不能直接拼接字符串（否则会有SQL注入风险）：

string filter = "alex, faheem, Cohen"; 
var filterArr = filter.Split(new []{','}, StringSplitOptions.RemoveEmptyEntries)
                      .Select(f => f.Trim())
                      .ToList(); 

var conditionParts = new List<string>();
var sqlParams = new List<SqlParameter>();

for (int i = 0; i < filterArr.Count; i++)
{
    var paramName = $"@NamePart{i}";
    conditionParts.Add($"Name LIKE '%' + {paramName} + '%'");
    sqlParams.Add(new SqlParameter(paramName, filterArr[i]));
}

var whereClause = string.Join(" OR ", conditionParts);
var users = DbContext.Users.FromSqlRaw($"SELECT * FROM Users WHERE {whereClause}", sqlParams.ToArray());

这个方法直接生成SQL语句，但参数化保证了安全性，适合一些对LINQ表达式不太熟悉的场景。

方案3：EF Core专属——用EF.Functions.Like #

如果你用的是EF Core，还可以用EF.Functions.Like来替代Contains()，结合PredicateBuilder效果一样：

using Microsoft.EntityFrameworkCore;

// ...

var matchPredicate = PredicateBuilder.False<User>();
foreach (var nameFragment in filterArr)
{
    var tempFragment = nameFragment;
    matchPredicate = matchPredicate.Or(u => EF.Functions.Like(u.Name, $"%{tempFragment}%"));
}

var users = DbContext.Users.Where(matchPredicate);

EF.Functions.Like会直接映射到SQL的LIKE操作，和Contains()效果几乎一致，但有时候能更灵活地控制通配符的位置。

总的来说，方案1是最推荐的，它既符合LINQ的编程习惯，又安全可靠，完美解决你的问题。

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