Cómo filtrar IEnumerable basado en un parámetro de entrada de entidad

Question

Estoy utilizando ahora Entity framework, pero es un problema "compartido" entre todos los ORM e incluso IEnumerable.

Digamos que tengo un método en el MVC se ve así:

[HttpPost] 
public ActionResult Foo(FooModel model) 
{ 
    var context = new Context(); -- The EF session 
    var data = context.Foo.Where(???).ToList(); 
    return View(data); 
} 

Quiero consultar el contexto basado en el parámetro de entrada como:

var data = context.Foo.Where(x => x.Date == model.Date && 
          x.Name == model.Name && 
          x.ItemCode = model.ItemCode).ToList(); 

pero es más complicado que eso, porque si uno de los parámetros anteriores (Date \ Name \ ItemCode) es nulo, no quiero incluirlo dentro de la consulta.
Si I Código difícil que puede ser similar a ésta:

var query = context.Foo; 

if (model.Date != null) 
    query =query.Where(x => x.Date == model.Date); 

if (model.ItemCode != null) 
    query =query.Where(x => x.ItemCode == model.ItemCode); 
... 

Tiene que haber una manera más simple que esto.
Necesito una forma de generar una expresión del tipo Expression<T, bool> para usar en el método Where.

[HttpPost] 
public ActionResult Foo(FooModel model) 
{ 
    var context = new Context(); -- The EF session 
    var data = context.Foo.Where(THE_EXPRESSION).ToList(); 
    return View(data); 
} 

¿Hay una forma incorporada de construir esa expresión? ¿Hay algún paquete en nuget que lo haga?

---

Actualización: Podría haber más de 30 properites en el modelo de entidad; escribir 30 veces el lugar para cada consulta puede ser un dolor en el cuello:

.Where(model.Date != null, x => x.Date == model.Date) 
.Where(model.Name != null, x => x.Name == model.Name) 
.Where(model.ItemCode != null, x => x.ItemCode == model.ItemCode) 
... 
... 
... 
.ToList(); 

Answer 1

Prueba eso. Esto usa reflexión y expresiones para construir la consulta dinámicamente. Lo probé solo con objetos.

static IQueryable<T> Filter<T>(IQueryable<T> col, T filter) 
{ 
    foreach (var pi in typeof(T).GetProperties()) 
    { 
     if (pi.GetValue(filter) != null) 
     { 
      var param = Expression.Parameter(typeof(T), "t"); 
      var body = Expression.Equal(
       Expression.PropertyOrField(param, pi.Name), 
       Expression.PropertyOrField(Expression.Constant(filter), pi.Name)); 
      var lambda = Expression.Lambda<Func<T, bool>>(body, param); 
      col = col.Where(lambda); 
     } 
    } 

    return col; 
} 

Answer 2

Su método codificado es el mejor método en general.

Sin embargo, puede intentar hacer su vida un poco más fácil al escribir un método de extensión apropiado para ayudar a mantener el código limpio.

probar esto por ejemplo:

public static class QueryableEx 
{ 
    public static IQueryable<T> Where<T>(
     this IQueryable<T> @this, 
     bool condition, 
     Expression<Func<T, bool>> @where) 
    { 
     return condition ? @this.Where(@where) : @this; 
    } 
} 

Ahora usted podría escribir este código:

[HttpPost] 
public ActionResult Foo(FooModel model) 
{ 
    using (var context = new Context()) 
    { 
     var data = context.Foo 
      .Where(model.Date != null, x => x.Date == model.Date) 
      .Where(model.Name != null, x => x.Name == model.Name) 
      .Where(model.ItemCode != null, x => x.ItemCode == model.ItemCode) 
      .ToList(); 
     return View(data); 
    } 
} 

(Por favor, no se olvide de deshacerse de su contexto o usar using que lo haga por usted.)

Answer 3

Creo que debe encapsular su lógica en su entidad Foo, por ejemplo

public Foo 
    { 
    public bool isMatch(Model model) 
    { 
     // check your rules and return result 
    } 
    } 

y úselo en linq. O mira Specification pattern