Comment traiter plusieurs clauses where dans une instruction LINQ?

Question

Merci à ceux qui ont répondu à mes last question j'ai obtenu le code ci-dessous pour travailler qui permet au développeur d'envoyer plusieurs clauses where à une méthode qui inclut chacun d'eux dans une déclaration LINQ. Cependant, comment puis-je obtenir l'inclusion des clauses where pour qu'elles soient dynamiques? Au lieu de cela:

return customers 
     .Where(whereClauses[0]) 
     .Where(whereClauses[1]) 
     .ToList(); 

quelque chose comme ça (pseudo-code):

List<Customer> customers = new List<Customer>(); 
foreach (var whereClause in whereClauses) 
{ 
    customers 
    .Where(whereClause...???) 
    .ToList(); 
} 
return customers; 

Voici le code qui fonctionne:

using System; 
using System.Collections.Generic; 
using System.Linq; 

namespace TestDynamicLinq2343 
{ 
    public class Program 
    { 
     static void Main(string[] args) 
     { 
      List<Customer> customers = Customer.GetCustomers(); 

      List<Func<Customer, bool>> whereClauses = new List<Func<Customer, bool>>(); 
      whereClauses.Add(c => c.LastName.ToUpper().Contains("A")); 
      whereClauses.Add(c => c.FirstName.ToUpper().Contains("J")); 

      foreach (var customer in Customer.GetFilteredCustomers(customers, whereClauses)) 
      { 
       Console.WriteLine(customer.LastName); 
      } 

      Console.ReadLine(); 
     } 
    } 

    public class Customer 
    { 
     public string FirstName { get; set; } 
     public string LastName { get; set; } 
     public string Street { get; set; } 
     public string Location { get; set; } 
     public string ZipCode { get; set; } 

     public static List<Customer> GetCustomers() 
     { 
      List<Customer> customers = new List<Customer>(); 
      customers.Add(new Customer { FirstName = "Jim", LastName = "Jones" }); 
      customers.Add(new Customer { FirstName = "Joe", LastName = "Adams" }); 
      customers.Add(new Customer { FirstName = "Jake", LastName = "Johnson" }); 
      customers.Add(new Customer { FirstName = "Angie", LastName = "Reckar" }); 
      customers.Add(new Customer { FirstName = "Jean", LastName = "Anderson" }); 
      return customers; 
     } 

     public static List<Customer> GetFilteredCustomers(List<Customer> customers, List<Func<Customer, bool>> whereClauses) 
     { 
      return customers 
        .Where(whereClauses[0]) 
        .Where(whereClauses[1]) 
        .ToList(); 
     } 
    } 
} 

Answer 1

IEnumerable<Customer> dbCustomers = customers; 
foreach (var whereClause in whereClauses) 
{ 
    dbCustomers = dbCustomers.Where(whereClause); 
} 
return dbCustomers.ToList(); 

extensionMethod peut-être intéressant :

public static class IEnumerableExtension 
{ 
    public static void AttachWhereClauses<T>(this IEnumerable<T> source, IEnumerable<Func<T, bool>> whereClauses) 
    { 
     foreach (var whereClause in whereClauses) 
     { 
      source = source.Where(whereClause); 
     } 
    } 
} 
var listedCustomers = customers.AttachWhereClauses(whereClauses).ToList(); 

mais: pas testé - je ne sais pas avec certitude, si l'attachement whereClauses pour le même objet fonctionne!

Answer 2

Quelque chose comme ceci:

public IEnumerable<Customer> ApplyConditions(IEnumerable<Func<Customer, bool>> conditions) 
{ 
    IEnumerable<Customer> customers = ...; 
    foreach(var condition in conditions) 
     customers = customers.Where(condition); 
    return customers; 
}