Linq z opcjonalnymi opcjami WHERE

Question

Mam funkcję .Net, która akceptuje 3 parametry, wszystkie opcjonalne. Coś takiego:

public List<MyObject> Search(string colour, string size, string name) 
{ 
    var result = (from c in MyTable where .... select c).ToList();  
} 

Moje pytanie brzmi, co jest najlepszym sposobem, aby zrobić where część. Czy najlepiej byłoby stworzyć dynamiczny linq? Jaki jest najlepszy wzór w linq, aby mieć opcjonalne parametry?

Więc w SQL, coś takiego:

SELECT * 
FROM MyTable 
WHERE (@colour <> '' AND colour = @colour) 
    AND (@size <> '' AND size = @size) 
    AND (@name <> '' AND name = @name) 

Ale mam nadzieję, że tam schludniejszy, bardziej akceptowalnego wzorca dla tej operacji w ciągu LINQ.

Answer 1

prostu łańcuch Where klauzule o sprawdzanie wartości null

var result = context.MyTable 
        .Where(t => color == null || color == t.Color) 
        .Where(t => size == null || size == t.Size) 
        .Where(t => name == null || name == t.Name) 
        .ToList() 

Answer 2

Można zrobić coś jak następuje w sposób Search:

var query = from c in MyTable select c; 
if (!String.IsNullOrEmpty(colour)) 
    query = from c in query where c.colour == colour select c; 
if (!String.IsNullOrEmpty(size)) 
    query = from c in query where c.size == size select c; 
if (!String.IsNullOrEmpty(name)) 
    query = from c in query where c.name == name select c; 
return query.ToList(); 

Answer 3

Jak o:

public List<MyObject> Search(string colour, string size, string name) 
{ 
    IEnumerable<MyObject> result = MyTable; 

    if(colour != null) 
     result = result.Where(o => o.Colour == colour); 

    if(size != null) 
     result = result.Where(o => o.Size == size); 

    ... 

    return result.ToList(); 
} 

Answer 4

var results = olstOfObjects.Where(x => 
    (x.size == size || x.size == "") && 
    (x.color == color || x.color == "") && 
    (x.name == name || x.name == "")).ToList(); 

Answer 5

W takich przypadkach, radzę ci używać PredicateBuilder generować twoje pytania. Możesz skopiować kod stąd lub zainstalować pakiet LinqKit Nuget.

Użycie tego kodu pozwoli na generowanie dynamicznych zapytań w locie i uniemożliwi zapisanie ton instrukcji if/else.

Oświadczenia takie jak ...

p => p.Price > 100 && 
p.Price < 1000 && 
(p.Description.Contains ("foo") || p.Description.Contains ("far")) 

będą generowane przez tego rodzaju kodu:

var inner = PredicateBuilder.False<Product>(); 
inner = inner.Or (p => p.Description.Contains ("foo")); 
inner = inner.Or (p => p.Description.Contains ("far")); 

var outer = PredicateBuilder.True<Product>(); 
outer = outer.And (p => p.Price > 100); 
outer = outer.And (p => p.Price < 1000); 
outer = outer.And (inner); 

myślę, że to jest dość schludny i będzie to również daje wiedzę na temat mocnych wyrażeń może być.

Answer 6

Tutaj masz 1 zapytanie ze wszystkimi warunkami:

public List<object> Search(string colour, string size, string name) 
{ 
    var query = from c in MyTable 
     where 
      (string.IsNullOrEmpty(colour) || c.colour == colour) && 
      (string.IsNullOrEmpty(size) || c.size == size) && 
      (string.IsNullOrEmpty(name) || c.name == name) 
     select c; 

    return query.ToList(); 
}