sqlmethods - LINQ to SQL-selecciona donde texto como matriz de cadenas

sqlmethods.like c#

Question

Tengo una lista <string > de conteo de variables, y quiero consultar (a través de LINQ) una tabla para encontrar elementos que contengan cualquiera de esas cadenas en la columna de texto.

Intenté esto (no funciona):

items = from dbt in database.Items
         where (stringList.FindAll(s => dbt.Text.Contains(s)).Count > 0)
         select dbt;

La consulta sería algo así como:

select * from items where text like ''%string1%'' or text like ''%string2%''

es posible?

Answer 1

Revisa este artículo para hacer lo que quieras:
http://www.albahari.com/nutshell/predicatebuilder.aspx

Esto funciona como un sueño. Básicamente corté y pegué su código y recuperé esto (con mi propio esquema de datos, por supuesto):

SELECT [t0].[Id], [t0].[DateCreated], [t0].[Name] ...
FROM [dbo].[Companies] AS [t0]
WHERE ([t0].[Name] LIKE @p0) OR ([t0].[Name] LIKE @p1)

Aquí está el código que ejecuté para la prueba de concepto:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace PredicateTest
{
class Program
{
    static void Main(string[] args)
    {
        DataClasses1DataContext dataContext = new DataClasses1DataContext();

        Program p = new Program();
        Program.SearchCompanies("test", "test2");
        var pr = from pi in  dataContext.Companies.Where(Program.SearchCompanies("test", "test2")) select pi;
    }

    DataClasses1DataContext dataContext = new DataClasses1DataContext();

    public static Expression<Func<Company, bool>> SearchCompanies(
                                                  params string[] keywords)
    {
        var predicate = PredicateBuilder.False<Company>();
        foreach (string keyword in keywords)
        {
            string temp = keyword;
            predicate = predicate.Or(p => p.Name.Contains(temp));
        }
        return predicate;
    }

}

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

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

    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1,
                                                         Expression<Func<T, bool>> expr2)
    {
        var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
        return Expression.Lambda<Func<T, bool>>
              (Expression.AndAlso(expr1.Body, invokedExpr), expr1.Parameters);
    }
}
}

Sugiero ir al sitio para obtener el código y la explicación.

(Dejo la primera respuesta porque funciona bien si necesita una declaración IN)

Answer 2

algo nuevo para todo el juego LINQ to SQL, pero ¿ayuda esta sintaxis?

string[] items = new string[] { "a", "b", "c", "d" };

var items = from i in db.Items
             where items.Contains(p.text)
            select i;

Lo tengo de:

http://blog.wekeroad.com/2008/02/27/creating-in-queries-with-linq-to-sql/

Answer 3

Después de leer esta publicación, buscando la misma solución que tú, encontré una solución con .Any y .All métodos para Linq son una forma sencilla y elegante de obtener resultados coincidentes para las matrices.

En este caso, estoy usando una entrada de búsqueda, separada por comas como ejemplo. No me importa si el partido no está en el mismo caso.

var qry = Query.Split('','').Select(c => c.Trim().ToLower());

Primero Obtenga algunos datos para consultar, desde Linq a SQL o donde sea

var search = db.tablename;

El uso de la sintaxis lambda para un buen código ajustado, y resulta en coincidencias con. .Any cadena en la consulta al nombre o la descripción en la tabla.

search = search.Where(
    record => 
    qry.Any(q => record.Name.ToLower().Contains(q)) || 
    qry.Any(q => record.Description.ToLower().Contains(q)));

Si solo desea resultados en los que coincidan todas las cadenas en cualquier campo, puede reemplazar. .Any con .All :

search = search.Where(
    record => 
    qry.All(q => record.Name.ToLower().Contains(q)) || 
    qry.All(q => record.Description.ToLower().Contains(q)));

Answer 4

Utilizando:

string searh = "test1 test2,test3";    
data.Persons.Search(p => p.Name, search);

La función de búsqueda es:

public static IQueryable<T> Search<T>(this IQueryable<T> source, Expression<Func<T, string>> selector, string s)
{
    if (string.IsNullOrEmpty(s))
        return source;

    string[] str = s.Split(new char[] { '' '', '','' }, StringSplitOptions.RemoveEmptyEntries);

    MethodInfo methodContains = typeof(string).GetMethod("Contains", new[] { typeof(string) });

    Expression strExpression;
    Expression expressionContains;
    Expression resultExpression = Expression.Empty();

    for (int i = 0; i < str.Length; i++)
    {
        strExpression = Expression.Constant(str[i].Trim(), typeof(string));
        expressionContains = Expression.Call(selector.Body, methodContains, strExpression);

        if (i == 0)
            resultExpression = expressionContains;
        else
            resultExpression = Expression.OrElse(resultExpression, expressionContains);
    }

    Expression<Func<T, bool>> lambdaExpr = Expression.Lambda<Func<T, bool>>(resultExpression, new ParameterExpression[] { selector.Parameters[0] });

    return source.Where(lambdaExpr);
}