像实体框架中的运算符？

Question

我们正在尝试在实体框架中为具有字符串字段的实体实现“LIKE”运算符，但似乎不受支持。有没有其他人尝试过这样的事情？

blog post 总结了我们遇到的问题。我们可以使用包含，但这仅匹配 LIKE 的最简单的情况。将 contains、startswith、endswith 和 indexof 组合在一起可以实现，但需要在标准通配符和 Linq to Entities 代码之间进行转换。

Answer 1

我对 EF 真的一无所知，但在 LINQ to SQL 中，您通常使用 String.Contains 来表达 LIKE 子句：

where entity.Name.Contains("xyz")

翻译成

WHERE Name LIKE '%xyz%'

（将StartsWith 和EndsWith 用于其他行为。）

我不完全确定这是否有帮助，因为当您说您尝试实施 LIKE 时，我不明白您的意思。如果我完全误解了，请告诉我，我会删除这个答案:)

Answer 2

这是一篇旧帖子，但对于任何正在寻找答案的人，this link 应该会有所帮助。如果您已经在使用 EF 6.2.x，请转至 this answer。如果您使用的是 EF Core 2.x，请致 this answer

短版：

SqlFunctions.PatIndex 方法 - 在所有有效的文本和字符数据类型上返回指定表达式中模式第一次出现的起始位置，如果未找到该模式，则返回零 p>

命名空间：System.Data.Objects.SqlClient 程序集：System.Data.Entity（在 System.Data.Entity.dll 中）

这个forum thread中也出现了一点解释。

Answer 3

我遇到了同样的问题。

目前，我已经解决了基于 http://www.codeproject.com/Articles/11556/Converting-Wildcards-to-Regexes?msg=1423024#xx1423024xx 的客户端通配符/正则表达式过滤 - 它很简单并且可以按预期工作。

我找到了关于这个主题的另一个讨论：http://forums.asp.net/t/1654093.aspx/2/10
如果您使用 Entity Framework >= 4.0，这篇文章看起来很有希望：

使用 SqlFunctions.PatIndex：

http://msdn.microsoft.com/en-us/library/system.data.objects.sqlclient.sqlfunctions.patindex.aspx

像这样：

var q = EFContext.Products.Where(x =>
SqlFunctions.PatIndex("%CD%BLUE%", x.ProductName) > 0);

注意：此解决方案仅适用于 SQL-Server，因为它使用非标准 PATINDEX 函数。

Answer 4

更新：在 EF 6.2 中有一个 like 运算符

Where(obj => DbFunctions.Like(obj.Column , "%expression%"))

Answer 5

Entity Framework Core 2.0中添加了LIKE运算符：

var query = from e in _context.Employees
                    where EF.Functions.Like(e.Title, "%developer%")
                    select e;

与... where e.Title.Contains("developer") ... 相比，它实际上被转换为SQL LIKE 而不是CHARINDEX 我们看到的Contains 方法。

Answer 6

在文档中特别提到它是 Entity SQL 的一部分。您收到错误消息了吗？

// LIKE and ESCAPE
// If an AdventureWorksEntities.Product contained a Name 
// with the value 'Down_Tube', the following query would find that 
// value.
Select value P.Name FROM AdventureWorksEntities.Product 
    as P where P.Name LIKE 'DownA_%' ESCAPE 'A'

// LIKE
Select value P.Name FROM AdventureWorksEntities.Product 
    as P where P.Name like 'BB%'

http://msdn.microsoft.com/en-us/library/bb399359.aspx

Answer 7

如果您使用的是 MS Sql，我已经编写了 2 个扩展方法来支持通配符搜索的 % 字符。 （需要 LinqKit）

public static class ExpressionExtension
{
    public static Expression<Func<T, bool>> Like<T>(Expression<Func<T, string>> expr, string likeValue)
    {
        var paramExpr = expr.Parameters.First();
        var memExpr = expr.Body;

        if (likeValue == null || likeValue.Contains('%') != true)
        {
            Expression<Func<string>> valExpr = () => likeValue;
            var eqExpr = Expression.Equal(memExpr, valExpr.Body);
            return Expression.Lambda<Func<T, bool>>(eqExpr, paramExpr);
        }

        if (likeValue.Replace("%", string.Empty).Length == 0)
        {
            return PredicateBuilder.True<T>();
        }

        likeValue = Regex.Replace(likeValue, "%+", "%");

        if (likeValue.Length > 2 && likeValue.Substring(1, likeValue.Length - 2).Contains('%'))
        {
            likeValue = likeValue.Replace("[", "[[]").Replace("_", "[_]");
            Expression<Func<string>> valExpr = () => likeValue;
            var patExpr = Expression.Call(typeof(SqlFunctions).GetMethod("PatIndex",
                new[] { typeof(string), typeof(string) }), valExpr.Body, memExpr);
            var neExpr = Expression.NotEqual(patExpr, Expression.Convert(Expression.Constant(0), typeof(int?)));
            return Expression.Lambda<Func<T, bool>>(neExpr, paramExpr);
        }

        if (likeValue.StartsWith("%"))
        {
            if (likeValue.EndsWith("%") == true)
            {
                likeValue = likeValue.Substring(1, likeValue.Length - 2);
                Expression<Func<string>> valExpr = () => likeValue;
                var containsExpr = Expression.Call(memExpr, typeof(String).GetMethod("Contains",
                    new[] { typeof(string) }), valExpr.Body);
                return Expression.Lambda<Func<T, bool>>(containsExpr, paramExpr);
            }
            else
            {
                likeValue = likeValue.Substring(1);
                Expression<Func<string>> valExpr = () => likeValue;
                var endsExpr = Expression.Call(memExpr, typeof(String).GetMethod("EndsWith",
                    new[] { typeof(string) }), valExpr.Body);
                return Expression.Lambda<Func<T, bool>>(endsExpr, paramExpr);
            }
        }
        else
        {
            likeValue = likeValue.Remove(likeValue.Length - 1);
            Expression<Func<string>> valExpr = () => likeValue;
            var startsExpr = Expression.Call(memExpr, typeof(String).GetMethod("StartsWith",
                new[] { typeof(string) }), valExpr.Body);
            return Expression.Lambda<Func<T, bool>>(startsExpr, paramExpr);
        }
    }

    public static Expression<Func<T, bool>> AndLike<T>(this Expression<Func<T, bool>> predicate, Expression<Func<T, string>> expr, string likeValue)
    {
        var andPredicate = Like(expr, likeValue);
        if (andPredicate != null)
        {
            predicate = predicate.And(andPredicate.Expand());
        }
        return predicate;
    }

    public static Expression<Func<T, bool>> OrLike<T>(this Expression<Func<T, bool>> predicate, Expression<Func<T, string>> expr, string likeValue)
    {
        var orPredicate = Like(expr, likeValue);
        if (orPredicate != null)
        {
            predicate = predicate.Or(orPredicate.Expand());
        }
        return predicate;
    }
}

用法

var orPredicate = PredicateBuilder.False<People>();
orPredicate = orPredicate.OrLike(per => per.Name, "He%llo%");
orPredicate = orPredicate.OrLike(per => per.Name, "%Hi%");

var predicate = PredicateBuilder.True<People>();
predicate = predicate.And(orPredicate.Expand());
predicate = predicate.AndLike(per => per.Status, "%Active");

var list = dbContext.Set<People>().Where(predicate.Expand()).ToList();    

在 ef6 中，它应该转换为

....
from People per
where (
    patindex(@p__linq__0, per.Name) <> 0
    or per.Name like @p__linq__1 escape '~'
) and per.Status like @p__linq__2 escape '~'

'，@p__linq__0 = '%He%llo%'，@p__linq__1 = '%Hi%'，@p__linq_2 = '%Active'

Answer 8

对于 EfCore，这里是构建 LIKE 表达式的示例

protected override Expression<Func<YourEntiry, bool>> BuildLikeExpression(string searchText)
    {
        var likeSearch = $"%{searchText}%";

        return t => EF.Functions.Like(t.Code, likeSearch)
                    || EF.Functions.Like(t.FirstName, likeSearch)
                    || EF.Functions.Like(t.LastName, likeSearch);
    }

//Calling method

var query = dbContext.Set<YourEntity>().Where(BuildLikeExpression("Text"));

Answer 9

你可以很容易地在 Link to Entities 中使用真实的like

添加

    <Function Name="String_Like" ReturnType="Edm.Boolean">
      <Parameter Name="searchingIn" Type="Edm.String" />
      <Parameter Name="lookingFor" Type="Edm.String" />
      <DefiningExpression>
        searchingIn LIKE lookingFor
      </DefiningExpression>
    </Function>

到你的 EDMX 在这个标签中：

edmx:Edmx/edmx:Runtime/edmx:ConceptualModels/Schema

还要记住<schema namespace="" /> 属性中的命名空间

然后在上面的命名空间中添加一个扩展类：

public static class Extensions
{
    [EdmFunction("DocTrails3.Net.Database.Models", "String_Like")]
    public static Boolean Like(this String searchingIn, String lookingFor)
    {
        throw new Exception("Not implemented");
    }
}

此扩展方法现在将映射到 EDMX 函数。

更多信息在这里：http://jendaperl.blogspot.be/2011/02/like-in-linq-to-entities.html