¿Cómo se usa SQL 'LIKE' con LINQ para Entidades?

Question

tengo un cuadro de texto que permite a un usuario especificar una cadena de búsqueda, incluyendo comodines, por ejemplo:

Joh* 
*Johnson 
*mit* 
*ack*on 

Antes de utilizar LINQ a Entidades, que tenía un procedimiento almacenado que se llevó a esa cadena como parámetro y lo hizo:

SELECT * FROM Table WHERE Name LIKE @searchTerm 

Y entonces yo sólo haría un String.Replace ('*', '%') antes de pasarlo en.

Ahora con LINQ a Entidades que estoy tratando de lograr lo mismo. Sé que hay compatibilidad con StartsWith, EndsWith y Contiene, pero no la admitirá de la manera que necesito.

leí sobre "SqlMethods.Like" y probamos este:

var people = from t in entities.People 
      where SqlMethods.Like(t.Name, searchTerm) 
      select new { t.Name }; 

Sin embargo estoy recibiendo la siguiente excepción:

LINQ to Entities does not recognize the method 'Boolean Like(System.String, 
System.String)' method, and this method cannot be translated into a store 
expression. 

¿Cómo voy a conseguir esta misma funcionalidad utilizando LINQ a Entidades?

Answer 1

http://social.msdn.microsoft.com/Forums/en-US/adodotnetentityframework/thread/6529a35b-6629-44fb-8ea4-3a44d232d6b9/

var people = entities.People.Where("it.Name LIKE @searchTerm", new ObjectParameter("searchTerm", searchTerm)); 

Answer 2

var people = from t in entities.People 
       where t.Name.ToLower().Contains(searchTerm.ToLower()) 
       select new { t.Name }; 

EDIT- I might be mixing sintax. Usualmente uso métodos de extensión; pero contiene funcionará.

Answer 3

Bueno, sus opciones son:

• Uso Contains. Sé que no te gusta, pero probablemente podría funcionar.
• Elija una función de SqlFunctions. Todos son compatibles con L2E.
• Map your own function.
• +1 a @Yury para ESQL.

Answer 4

Incluso se puede añadir soporte para un método .Como() dentro de LINQ a Entidades para entonces, en lugar de la propuesta (y trabajar)

var people = entities.People.Where("it.Name LIKE @searchTerm", new ObjectParameter("searchTerm", searchTerm)); 

es sólo

var people = entities.People.Where(p => p.Name.Like(searchTerm)); 

Ver http://jendaperl.blogspot.com/2011/02/like-in-linq-to-entities.html

Answer 5

Usted puede hacer esto:

using System.Data.Entity; // EntityFramework.dll v4.3 
var queryResult=db.Accounts.AsQueryable().Where(x => x.Name.Contains(queryKey)); 

porque LINQ a Entity no puede transformar el método Contains() al SQL, pero LINQ a SQL puede hacer esto. Traté de encontrar un método que pueda hacer un cast, al fin, AsQueryable(), también una versión genérica AsQueryable<T>(). Descubrí que puedo hacer esto utilizándolo de esta manera en mi caso, pero no sé si tiene algún efecto colateral, tal vez perderá alguna función al Entity.

Answer 6

Cómo conseguir que funcione a la perfección:

en su modelo EDMX, 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> 

justo después de las secciones que se inician:

<edmx:ConceptualModels> <Schema Namespace="Your.Namespace"...

Entonces, en cualquier parte su código, agregue este método de extensión:

//prior to EF 6 [System.Data.Objects.DataClasses.EdmFunction("Your.Namespace", "String_Like")] 

    //With EF 6 
    [System.Data.Entity.DbFunction("Your.Namespace", "String_Like")] 
    public static bool Like(this string input, string pattern) 
    { 
     /* Turn "off" all regular expression related syntax in 
     * the pattern string. */ 
     pattern = Regex.Escape(pattern); 

     /* Replace the SQL LIKE wildcard metacharacters with the 
     * equivalent regular expression metacharacters. */ 
     pattern = pattern.Replace("%", ".*?").Replace("_", "."); 

     /* The previous call to Regex.Escape actually turned off 
     * too many metacharacters, i.e. those which are recognized by 
     * both the regular expression engine and the SQL LIKE 
     * statement ([...] and [^...]). Those metacharacters have 
     * to be manually unescaped here. */ 
     pattern = pattern.Replace(@"\[", "[").Replace(@"\]", "]").Replace(@"\^", "^"); 

     return Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase); 
    } 

Y ya lo tienes.

Ahora se puede hacer:

(from e in Entities 
where e.Name like '%dfghj%' 
select e) 

o

string [] test = {"Sydney", "Melbourne", "adelaide", "ryde"}; 

test.Where(t=> t.Like("%yd%e%")).Dump(); 

Answer 7

usted puede hacer todas estas declaraciones con LINQ como esto

string _search = "blow"; 
// joh* OR joh% 
items.Where(i => i.Name.StartsWith(_search, StringComparison.OrdinalIgnoreCase)); 
// *son OR %son 
items.Where(i => i.Name.EndsWith(_search, StringComparison.OrdinalIgnoreCase)); 
// *hns* OR %hns% 
items.Where(i => i.Name.ToLower().Contains(_search)); 

Answer 8

la solución es utilizar SQLFunctions.PatIndex

var result = from c in items 
      where SqlFunctions.PatIndex(searchstring.ToLower(), c.fieldtoSearch) > 0 
      select c; 

donde 'searchstring' es el patrón para buscar 'fieldtoSearch' es el campo para buscar

patindex() permite la búsqueda mediante la búsqueda patrón de encordado. La búsqueda no distingue entre mayúsculas y minúsculas.

Answer 9

No necesita utilizar el signo de porcentaje durante el filtrado. p.ej;

si quiero comprobar NombreDeElemento no contiene '-' Voy a hacerlo de esta manera

Item.ItemName.Contains! ("-")

En SQL que convertirá a no me gusta ' % -% '

Answer 10

Utilizamos Database First y EntityFramework.

"Asigna tu propia función". el acercamiento funciona para nosotros junto con el nuget EntityFramework.CodeFirstStoreFunctions.

1 Paso: Crear una función en el PP como esto:

CREATE FUNCTION [dbo].[StringLike] 
(
     @a nvarchar(4000), 
     @b nvarchar(4000) 
) 
RETURNS bit 
AS 
BEGIN 
    RETURN 
    (SELECT CASE 
      WHEN (SELECT 1 WHERE @a LIKE @b) = 1 THEN 1 
      ELSE 0 
      END) 
END 

2 Paso: Instalar EntityFramework.CodeFirstStoreFunctions NuGet

3 Paso: Crear un método en su código como este (creo mía en la clase DbContext):

[DbFunction("CodeFirstDatabaseSchema", "StringLike")] 
public static bool Like(string input, string pattern) 
{ 
    throw new NotSupportedException("Direct calls are not supported."); 
} 

4 Paso: inicializar EntityFramework.CodeFirstStoreFunctions.

protected override void OnModelCreating(DbModelBuilder modelBuilder) 
{ 
    modelBuilder.Conventions.Add(new FunctionsConvention("dbo", this.GetType())); 
} 

5 Paso: Ahora puede utilizar este método en su consulta linq.