¿Como operador en Entity Framework?

Estamos tratando de implementar el operador "LIKE" en Entity Framework para nuestras entidades con campos de cadena, pero no parece ser compatible. ¿Alguien más ha intentado hacer algo como esto?

Esta publicación de blog resume el problema que tenemos. Podríamos usar contiene, pero eso solo coincide con el caso más trivial de LIKE. La combinación de contains, startswith, endswith e indexof nos lleva allí, pero requiere una traducción entre comodines estándar y código Linq to Entities.

Esta es una publicación antigua ahora, pero para cualquiera que busque la respuesta, este enlace debería ayudar. Vaya a esta respuesta si ya está usando EF 6.2.x. A esta respuesta si está usando EF Core 2.x

Version corta:

Método SqlFunctions.PatIndex : devuelve la posición inicial de la primera aparición de un patrón en una expresión especificada, o ceros si no se encuentra el patrón, en todos los tipos de datos de texto y caracteres válidos

Espacio de nombres: System.Data.Objects.SqlClient Ensamblado: System.Data.Entity (en System.Data.Entity.dll)

También aparece una pequeña explicación en este hilo del foro .

Realmente no sé nada sobre EF, pero en LINQ to SQL generalmente expresas una cláusula LIKE usando String.Contains:

where entity.Name.Contains("xyz")

se traduce en

WHERE Name LIKE '%xyz%'

(Uso StartsWithy EndsWithpara otro comportamiento).

No estoy completamente seguro de si eso es útil, porque no entiendo lo que quiere decir cuando dice que está tratando de implementar LIKE. Si he entendido mal por completo, avíseme y eliminaré esta respuesta :)

Yo tuve el mismo problema.

Por ahora, me he conformado con el filtrado Wildcard / Regex del lado del cliente basado en http://www.codeproject.com/Articles/11556/Converting-Wildcards-to-Regexes?msg=1423024#xx1423024xx - es simple y funciona como esperado.

Encontré otra discusión sobre este tema: http://forums.asp.net/t/1654093.aspx/2/10
Esta publicación parece prometedora si usa Entity Framework> = 4.0:

Utilice SqlFunctions.PatIndex:

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

Me gusta esto:

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

Nota: esta solución es solo para SQL-Server, ya que utiliza una función PATINDEX no estándar.

Actualización: en EF 6.2 hay un operador similar

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

Hay un LIKEoperador agregado en Entity Framework Core 2.0:

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

Compararlo ... where e.Title.Contains("developer") ...se traduce en realidad en SQL LIKElugar de CHARINDEXverlo como Containsmétodo.

Se menciona específicamente en la documentación como parte de Entity SQL. ¿Está recibiendo un mensaje de error?

// 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

si está utilizando MS Sql, he escrito 2 métodos de extensión para admitir el carácter% para la búsqueda con comodines. (Se requiere 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;
    }
}

uso

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();    

en ef6 y debería traducirse a

....
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 ='% Hola% ', @ p__linq_2 ='% Activo '

Para EfCore, aquí hay una muestra para construir una expresión 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"));

Puede usar un Me gusta real en Enlace a entidades con bastante facilidad

Añadir

    <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>

a su EDMX en esta etiqueta:

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

También recuerde el espacio de nombres en el <schema namespace="" />atributo

Luego agregue una clase de extensión en el espacio de nombres anterior:

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");
    }
}

Este método de extensión ahora se asignará a la función EDMX.

Más información aquí: http://jendaperl.blogspot.be/2011/02/like-in-linq-to-entities.html