Cláusula WHERE dinámica en LINQ

Question

¿Cuál es la mejor manera de ensamblar una cláusula WHERE dinámica a una instrucción LINQ?

que tienen varias docenas de casillas de verificación en un formulario y los estoy pasando atrás como: Diccionario < cadena, cadena Lista < > > (Diccionario < fieldName, Lista <valores> >) a mi consulta LINQ.

public IOrderedQueryable<ProductDetail> GetProductList(string productGroupName, string productTypeName, Dictionary<string,List<string>> filterDictionary) 
{ 
    var q = from c in db.ProductDetail 
      where c.ProductGroupName == productGroupName && c.ProductTypeName == productTypeName 
      // insert dynamic filter here 
      orderby c.ProductTypeName 
      select c; 
    return q; 
} 

Answer 1

alt text http://www.scottgu.com/blogposts/dynquery/step2.png

se necesita algo como esto? Use the Linq Dynamic Query Library (la descarga incluye ejemplos).

Consulte ScottGu's blog para ver más ejemplos.

Answer 2

Tenía la misma pregunta (User defined filter for linq), y @tvanfosson me habló de Dynamic Linq (http://code.msdn.microsoft.com/csharpsamples).

Answer 3

También puede usar PredicateBuilder de LinqKit para encadenar múltiples expresiones lambda de tipo seguro usando O o Y.

http://www.albahari.com/nutshell/predicatebuilder.aspx

Answer 4

Un enfoque simple puede ser si sus columnas son de tipo simple como cuerdas

public static IEnumerable<MyObject> WhereQuery(IEnumerable<MyObject> source, string columnName, string propertyValue) 
{ 
    return source.Where(m => { return m.GetType().GetProperty(columnName).GetValue(m, null).ToString().StartsWith(propertyValue); }); 
} 

Answer 5

Se puede usar el método de extensión Cualquier(). Lo siguiente parece funcionar para mí.

XStreamingElement root = new XStreamingElement("Results", 
       from el in StreamProductItem(file) 
       where fieldsToSearch.Any(s => el.Element(s) != null && el.Element(s).Value.Contains(searchTerm)) 
       select fieldsToReturn.Select(r => (r == "product") ? el : el.Element(r)) 
      ); 
      Console.WriteLine(root.ToString()); 

Donde 'fieldsToSearch' y 'fieldsToReturn' son los dos objetos List.

Answer 6

Este proyecto en CodePlex tiene lo que desea.

System.Linq.Dynamic - http://dynamiclinq.codeplex.com/

Descripción del Proyecto

Extiende System.Linq.Dynamic para apoyar la ejecución de las expresiones lambda definidos en una cadena contra el marco de la entidad o de cualquier proveedor que admite IQueryable.

Como se trata de una extensión del código fuente se puede encontrar en Scott Guthrie's Blog que le permitirá hacer cosas como esta:

Y cosas como esta:

Answer 7

Encontré una solución que incluso yo puedo entender ... usando el método 'Contiene' puedes encadenar tantos DONDE como tú me gusta. Si WHERE es una cadena vacía, se ignora (o se evalúa como una selección de todo). Aquí está mi ejemplo de unir 2 tablas en LINQ, aplicar múltiples cláusulas where y rellenar una clase de modelo para devolverla a la vista. (esto es un seleccionar todo).

public ActionResult Index() 
    { 
     string AssetGroupCode = ""; 
     string StatusCode = ""; 
     string SearchString = ""; 

     var mdl = from a in _db.Assets 
        join t in _db.Tags on a.ASSETID equals t.ASSETID 
        where a.ASSETGROUPCODE.Contains(AssetGroupCode) 
        && a.STATUSCODE.Contains(StatusCode) 
        && (
        a.PO.Contains(SearchString) 
        || a.MODEL.Contains(SearchString) 
        || a.USERNAME.Contains(SearchString) 
        || a.LOCATION.Contains(SearchString) 
        || t.TAGNUMBER.Contains(SearchString) 
        || t.SERIALNUMBER.Contains(SearchString) 
       ) 
        select new AssetListView 
        { 
         AssetId = a.ASSETID, 
         TagId = t.TAGID, 
         PO = a.PO, 
         Model = a.MODEL, 
         UserName = a.USERNAME, 
         Location = a.LOCATION, 
         Tag = t.TAGNUMBER, 
         SerialNum = t.SERIALNUMBER 
        }; 


     return View(mdl); 
    } 

Answer 8

I tienen escenario similar donde necesito añadir filtros basados ​​en la entrada del usuario y I de cadena El cláusula where.

Aquí está el código de muestra.

var votes = db.Votes.Where(r => r.SurveyID == surveyId); 
if (fromDate != null) 
{ 
    votes = votes.Where(r => r.VoteDate.Value >= fromDate); 
} 
if (toDate != null) 
{ 
    votes = votes.Where(r => r.VoteDate.Value <= toDate); 
} 
votes = votes.Take(LimitRows).OrderByDescending(r => r.VoteDate); 

Answer 9

Esta es la solución que se me ocurrió si a alguien le interesa.

https://kellyschronicles.wordpress.com/2017/12/16/dynamic-predicate-for-a-linq-query/

Primero identificar el tipo de elemento único que tenemos que utilizar (De TROW Como DataRow) y luego identificar la “fuente” estamos utilizando y atar el identificador a esa fuente ((fuente Como TypedTableBase (De TRow)). Luego, debemos especificar el predicado, o la cláusula WHERE que se va a pasar (predicado como Func (Of TRow, Boolean)) que se devolverá como verdadero o falso. A continuación, identificaremos cómo queremos que se devuelva información ordenada (OrderByField As String). Nuestra función devolverá una EnumerableRowCollection (Of TRow), nuestra colección de datarows que han cumplido las condiciones de nuestro predicado (EnumerableRowCollection (Of TRow)). Este es un ejemplo básico. Por supuesto, debe asegúrese de que su campo de pedido no contenga nu lls, o han manejado esa situación correctamente y se aseguran de que los nombres de sus columnas (si está utilizando un origen de datos fuertemente tipado no importen, cambiarán el nombre de las columnas) son estándar.