Newsgroup: it.comp.dotnet
Titolo: Divertirsi un po' con gli Expression Tree

Ciao a tutti,
prendendo spunto da questo post di Raf:
http://blogs.ugidotnet.org/raffaele/archive/2009/04/17/un-po-di-free-style-con-linq-e-gli-expression-tree.aspx
ho provato questa cosa qui. Ho una classe
public class Person
{
	Int32 Age { get; }
}
e un metodo che ne fa la ricerca in una sorgente dati che implementa 
IQueryable<Person> (nella fattispecie, una sessio di NHibernate), così:
public IList<Person> Find(int? minAge, int? maxAge)
{
	//...
}
che ritorna tutte le persone con 'Age' maggiore di minAge (se definito) 
e minore di maxAge (se definito). Mi piaceva fare una cosa così:
protected readonly Func<int, Expression<Func<Person, bool>>> 
FilterByMinAge = min => (p => p.Age >= min);
protected readonly Func<int, Expression<Func<Person, bool>>> 
FilterByMaxAge = max => (p => p.Age <= max);
Expression<Func<Person, bool>> whereClause = null;
IQueryable<Person> query = ...;
//blablabla
if (where != null) query = query.Where(where);
return query.ToList();
Il mio problema è: come costruisco il BLABLABLA? :-) Nel senso: sulla 
base dei valori dei parametri minAge e maxAge e della loro eventuale 
nullità, come faccio a definire dinamicamente la expression da passare 
poi al provider linq?
Grazie,
Giulio
p.s. un problema "a latere" sarebbe: come faccio a testare 
"separatamente" la generazione di tale expression? Non riesco proprio a 
figurarmi nessun modo per farlo. Anche riguardo a questo problema, ogni 
suggerimento è strabene accetto! :-)
--

 linq?
PredicateBuilder :-)
http://www.albahari.com/nutshell/predicatebuilder.aspx
.m
-- 
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com
blog @ 
http://milestone.topics.it
whynot [ at ] topics [ dot ] it

 
http://www.albahari.com/nutshell/predicatebuilder.aspx
Uhm... segue un approccio molto simile a quello che ho seguito io 
"artigianalmente"... peraltro approccio a cui sono arrivato scopiazzando 
qua e là, e anche dalla fonte da te linkata! :-)
Leggendo il post, tuttavia, ci sono cose che mi lasciano un po' 
perplesso e già che ci siamo... :-) Ad esempio, non capisco quanto sia 
"ortodossa" la scelta di mettere su una cosa del genere:
public partial class Product
{
   public static Expression<Func<Product, bool>> IsSelling()
   {
     return p => !p.Discontinued && p.LastSale > DateTime.Now.AddDays (-30);
   }
}
Tu/voi che ne pensi/pensate?
Ciao,
Giulio
-- 

 Tu/voi che ne pensi/pensate?
sinceramente non saprei, sono molto condizionato dall'approccio basato 
su "Specification" quindi probabilmente poco obiettivo.
Mi piace molto l'idea del Layered Expression Tree proposta da Andrea 
Saltarello, e in quell'ottica probabilmente quella cosa ha un suo 
perchè.


 Saltarello, e in quell'ottica probabilmente quella cosa ha un suo perchè.
L'approccio LET l'ho seguito pure io, ma non gli avevo mai dato un nome 
(grazie Andrea! :-)) però... non significa solo rimbalzare un 
IQueryable<T> in giro per il mondo, finché non abbiamo la nostra query e 
lì poi "risolverla"? In che senso dici che nell'ottica LET mettere un 
metodo statico nell'entità ha un suo perché? Io non la trovo una brutta 
scelta (se non quando, ad esempio, ti trovi ad avere una interfaccia... 
e allora lì son dolori), ma mi sembra un appesantimento "tassonomico" 
abbastanza importante. :-)
In generale: per approccio basato su Specification cosa intendi? 
Potresti farmi un qualche esempio?
Grazie e buona giornata,
Giulio
--