Utilizzando Dove (Expression <Func <T, bool>>) in IGrouping

Question

Si consideri il seguente query LINQ to Entities:

return (from lead in db.Leads 
    join postcodeEnProvincie in postcodeEnProvincies 
    on lead.Postcode equals postcodeEnProvincie.Postcode 
    where (lead.CreationDate >= range.StartDate) && (lead.CreationDate <= range.EndDate) 
    group lead by postcodeEnProvincie.Provincie into g 
    select new Web.Models.GroupedLeads() { 
     GroupName = g.Key, 
     HotLeads = g.Count(l => l.Type == Data.LeadType.Hot), 
     Leads = g.Count(), 
     PriorityLeads = g.Count(l => l.Type == Data.LeadType.Priority), 
     Sales = g.Count(l => l.Sold), 
     ProductA = g.Count(l => l.Producten.Any(a => ((a.Name.Equals("productA", StringComparison.CurrentCultureIgnoreCase)) || (a.Parent.Name.Equals("productA", StringComparison.CurrentCultureIgnoreCase))))), 
     ProductB = g.Count(l => l.Producten.Any(a => ((a.Name.Equals("productB", StringComparison.CurrentCultureIgnoreCase)) || (a.Parent.Name.Equals("productB", StringComparison.CurrentCultureIgnoreCase))))), 
     ProductC = g.Count(l => l.Producten.Any(a => ((a.Name.Equals("productC", StringComparison.CurrentCultureIgnoreCase)) || (a.Parent.Name.Equals("productC", StringComparison.CurrentCultureIgnoreCase))))), 
     ProductC = g.Count(l => l.Producten.Any(a => ((a.Name.Equals("productD", StringComparison.CurrentCultureIgnoreCase)) || (a.Parent.Name.Equals("productD", StringComparison.CurrentCultureIgnoreCase))))) 
}).ToList(); 

Se siete come me, le dita dei piedi arricciarsi la ripetizione della logica di selezione del prodotto. Questo schema si ripete anche in un altro punto. Ho prima tentato di sostituirlo con un metodo di estensione su IEnumerable, che ovviamente non funziona: Linq to Entities ha bisogno di un'espressione per analizzare e tradurre.
così ho creato questo metodo:

public static System.Linq.Expressions.Expression<Func<Data.Lead, bool>> ContainingProductEx(string productName) 
    { 
     var ignoreCase = StringComparison.CurrentCultureIgnoreCase; 

     return (Data.Lead lead) => 
      lead.Producten.Any(
       (product => 
        product.Name.Equals(productName, ignoreCase) || 
        product.Parent.Name.Equals(productName, ignoreCase) 
       )); 
    } 

La seguente selezione ora funziona perfettamente bene:

var test = db.Leads.Where(Extensions.ContainingProductEx("productA")).ToList(); 

Tuttavia, questo non si compila, perché IGrouping non contiene un override di Dove che accetta un espressione:

return (from lead in db.Leads 
     join postcodeEnProvincie in postcodeEnProvincies 
     on lead.Postcode equals postcodeEnProvincie.Postcode 
     where (lead.CreationDate >= range.StartDate) && (lead.CreationDate <= range.EndDate) 
     group lead by postcodeEnProvincie.Provincie into g 
     select new Web.Models.GroupedLeads() 
     { 
      GroupName = g.Key, 
      HotLeads = g 
       .Where(l => l.Type == Data.LeadType.Hot) 
       .Count(), 
      Leads = g.Count(), 
      PriorityLeads = g 
       .Where(l => l.Type == Data.LeadType.Priority) 
       .Count(), 
      Sales = g 
       .Where(l => l.Sold) 
       .Count(), 
      ProductA = g 
       .Where(Extensions.ContainingProductEx("productA")) 
       .Count(), 
      ProductB = g 
       .Where(Extensions.ContainingProductEx("productB")) 
       .Count(), 
      ProductC = g 
       .Where(Extensions.ContainingProductEx("productC")) 
       .Count(), 
      ProductD = g 
       .Where(Extensions.ContainingProductEx("productD")) 
       .Count() 
     }).ToList(); 

Casting g di IQueryable compila, ma poi produce un "errore di provider di dati .NET Framework interno 1025.".

C'è un modo per avvolgere questa logica nel proprio metodo?

Answer 1

Invece di preoccuparsi di creare un puntatore/espressione di funzione all'interno della query a cui è possibile fare riferimento (potrebbe non essere possibile), perché non creare un metodo privato separato che prende uno IEnumerable<Lead>, una stringa e restituisce un riferimento e un riferimento il gruppo metodo nella tua query? Penso che la tua confusione derivi dal tentativo di creare un metodo di estensione sulla collezione invece di creare un metodo che nella collezione e il valore che stai cercando.

Qualcosa di simile:

ProductA = GetLeadsForProduct(g, "productA")

private int GetLeadsForProduct(IEnumerable<Lead> leads, string productType) 
{ 
    return leads.Count(l => l.Producten.Any(a => ((a.Name.Equals(productType, StringComparison.CurrentCultureIgnoreCase)) || (a.Parent.Name.Equals(productType, StringComparison.CurrentCultureIgnoreCase))))) 
} 

Answer 2

Questo è un problema che può essere risolto utilizzando LINQKit. Permette alle espressioni di essere invocate da altre espressioni e inline l'espressione invocata all'interno del suo chiamante. Purtroppo, supporta solo una manciata di situazioni molto specifiche, quindi dovremo adattare un po 'il tuo metodo di generazione delle espressioni.

Invece di passare il nome del prodotto per il metodo di generazione di espressione, avremo che si tratti di un parametro dell'espressione restituita:

public static Expression<Func<Data.Lead, string, bool>> ContainingProductEx() 
{ 
    var ignoreCase = StringComparison.CurrentCultureIgnoreCase; 

    return (lead, productName) => 
     lead.Producten.Any(
      (product => 
       product.Name.Equals(productName, ignoreCase) || 
       product.Parent.Name.Equals(productName, ignoreCase) 
      )); 
} 

successivo avremo bisogno di chiamare il metodo prima di dichiarare la query:

var predicate = Extensions.ContainingProductEx(); 

vostra query può ora può essere scritta come:

from lead in db.Leads.AsExpandable() 
//... 
    ProductA = g 
     .Where(lead => predicate.Invoke(lead, "productA")) 
     .Count(), 
    ProductB = g 
     .Where(lead => predicate.Invoke(lead, "productB")) 
     .Count(), 
    ProductC = g 
     .Where(lead => predicate.Invoke(lead, "productC")) 
     .Count(), 
    ProductD = g 
     .Where(lead => predicate.Invoke(lead, "productD")) 
     .Count()