Cómo reutilizar cláusulas where en consultas de Linq a SQL

Question

Tengo usuarios buscando registros de tipo Record. Teclean un término de búsqueda en un cuadro de texto y luego busco registros haciendo coincidir varios campos con el término de búsqueda.

Mi consulta es así:

var results = from record in DataContext.Records 
       where 
        record.Field1.ToLower().Contains(term) || 
        record.Field2.ToLower().Contains(term) || 
        record.Field3.ToLower().Contains(term) 
       select record; 

Tengo un número de consultas que todos utilizan el mismo filtro y por lo tanto me gustaría extraer el filtrado para que pueda ser reutilizado. Algo así como:

var filter = new Func<Record, string, bool>(
       (record, term) => 
        record.Field1.ToLower().Contains(term) || 
        record.Field2.ToLower().Contains(term) || 
        record.Field3.ToLower().Contains(term) 
      ); 

var results = from record in DataContext.Records 
       where filter(record, term) 
       select record; 

Sin embargo, esto no funcionará porque:

Método 'System.Object DynamicInvoke (System.Object [])' no tiene traducción apoyado a SQL.

¿Cómo puedo volver a utilizar mi condición de estado en las consultas?

Answer 1

Utilice un CompiledQuery!

var filter = CompiledQuery.Compile(
    (DatabaseDataContext dc, Record record, string term) => 
     record.Field1.ToLower().Contains(term) || 
     record.Field2.ToLower().Contains(term) || 
     record.Field3.ToLower().Contains(term) 
); 

var results = from record in DataContext.Records 
       where filter(DataContext, record, term) 
       select record; 

Para obtener más información, vea How to: Store and Reuse Queries.

Answer 2

Creo que necesitas convertirlo en Expression<Func<Record, bool>>. De lo contrario, está tratando de traducir la llamada del método C# real a SQL en lugar de la descripción de la misma. Esto no es una garantía de que esta versión funcionará; No estoy seguro de qué funciones de cadena se pueden traducir a SQL.

Answer 3

Es necesario construir una expresión en lugar de una función:

Expression<Func<Record, bool>> filter = 
    record => record.Field1.ToLower().Contains(term); // rest omitted 

La expresión lambda sigue siendo la misma, pero hay que volver en una variable de tipo Expression<Func<Record, bool>> - que hará que el compilador de C# de compilación como una expresión en lugar de un delegado, lo que le permite pasar a LINQ to SQL.

Sin embargo, usted no será capaz de utilizar una variable de expresión con un C# -Sintaxis cláusula where: usted tendrá que usar el método de extensión Dónde:

var results = DataContext.Records.Where(filter); 

Editado para agregar: Si usted quiere ser capaz de crear filtros en diferentes términos, sólo tiene un método para producir una expresión de un término:

private static Expression<Func<Record, bool>> Filter(string term) 
{ 
    return r => r.Field1.ToLower().Contains(term); 
} 

var results = DataContext.Records.Where(Filter(term)); 

Si prefiere mantener filter como lambda y cuando usted tiene en este momento, se puede hazlo, pero los genéricos ser un poco anidado:

Func<string, Expression<Func<Record, bool>>> filter = 
    term => (r => r.Field1.ToLower().Contains(term)); 

var results = DataContext.Records.Where(filter(term)); 

En cualquier caso, lo importante es que lo que sucede en el caso de la cláusula debe ser un Expression<Func<Record, bool>> - pero como se muestra más arriba, puede hacer que la expresión depende de term mediante la construcción de una expresión adecuada en el mosca. Que es exactamente lo que LINQ to SQL estaría haciendo si deletreara el filtro a mano en la cláusula Where.

Answer 4

Además del problema Expression<Func<Record, bool>> que otros han señalado, sugiero buscar en PredicateBuilder. Es muy bueno para combinar dinámicamente expresiones lambda.