Creazione di un albero di espressioni dinamiche per filtrare su una proprietà di raccolta

Question

Sto provando a creare un'espressione lambda che verrà combinata con altri in un albero di espressioni piuttosto grande per il filtro. Funziona bene fino a quando non ho bisogno di filtrare da una proprietà di sub-raccolta.

Come si costruisce un'espressione Lambda che filtra utilizzando Any() su una proprietà di una raccolta che è una proprietà dell'oggetto root?

Esempio:

CurrentDataSource.Offices.Where(o => o.base_Trades.Any(t => t.Name == "test")) 

Questo è come vorrei costruire l'espressione in modo statico, ma ho bisogno di costruire in modo dinamico. Dispiace per la confusione.

Edit: Ecco un frammento di come gestire le espressioni meno complicate:

IQueryable<Office> officeQuery = CurrentDataSource.Offices.AsQueryable<Office>(); 
ParameterExpression pe = Expression.Parameter(typeof(Office), "Office"); 
ParameterExpression tpe = Expression.Parameter(typeof(Trades), "Trades"); 

Expression SimpleWhere = null; 
Expression ComplexWhere = null; 
foreach (ServerSideFilterObject fo in ssfo) 
{ 
    SimpleWhere = null; 
    foreach (String value in fo.FilterValues) 
    { 
     if (!CollectionProperties.Contains(fo.PropertyName)) 
     { 
      //Handle singleton lambda logic here. 
      Expression left = Expression.Property(pe, typeof(Office).GetProperty(fo.PropertyName)); 
      Expression right = Expression.Constant(value); 
      if (SimpleWhere == null) 
      { 
       SimpleWhere = Expression.Equal(left, right); 
      } 
      else 
      { 
       Expression e1 = Expression.Equal(left, right); 
       SimpleWhere = Expression.Or(SimpleWhere, e1); 
      } 
     } 
     else 
     { 
      //handle inner Collection lambda logic here. 
      Expression left = Expression.Property(tpe, typeof(Trades).GetProperty("Name")); 
      Expression right = Expression.Constant(value); 
      Expression InnerLambda = Expression.Equal(left, right); 

      //Problem area. 
      Expression OfficeAndProperty = Expression.Property(pe, typeof(Office).GetProperty(fo.PropertyName)); 
      Expression OuterLambda = Expression.Call(OfficeAndProperty, typeof(Trades).GetMethod("Any", new Type[] { typeof(Expression) }),InnerLambda); 

      if (SimpleWhere == null) 
       SimpleWhere = OuterLambda; 
      else 
       SimpleWhere = Expression.Or(SimpleWhere, OuterLambda); 
     } 
    } 
    if (ComplexWhere == null) 
     ComplexWhere = SimpleWhere; 
    else 
     ComplexWhere = Expression.And(ComplexWhere, SimpleWhere); 
} 
MethodCallExpression whereCallExpression = Expression.Call(typeof(Queryable), "Where", new Type[] { officeQuery.ElementType }, officeQuery.Expression, Expression.Lambda<Func<Office, bool>>(ComplexWhere, new ParameterExpression[] { pe })); 
results = officeQuery.Provider.CreateQuery<Office>(whereCallExpression); 

Answer 1

trovato la soluzione. Non stavo cercando il metodo nel posto giusto prima.

Expression left = Expression.Property(tpe, typeof(Trades).GetProperty("Name")); 
Expression right = Expression.Constant(value); 
Expression InnerLambda = Expression.Equal(left, right); 
Expression<Func<Trades, bool>> innerFunction = Expression.Lambda<Func<Trades, bool>>(InnerLambda, tpe); 

method = typeof(Enumerable).GetMethods().Where(m => m.Name == "Any" && m.GetParameters().Length == 2).Single().MakeGenericMethod(typeof(Trades)); 
OuterLambda = Expression.Call(method, Expression.Property(pe, typeof(Office).GetProperty(fo.PropertyName)),innerFunction); 

Answer 2

Quello che avete elencato come esempio funziona in base a un commento. Ecco un esempio di quello che ho lavorare con:

Templates.Where(t => t.TemplateFields.Any(f => f.Required == 'Y')) 

Abbiamo modelli che hanno raccolta specifica di campi, e quei campi potrebbe essere richiesto. Quindi posso ottenere i modelli in cui qualsiasi campo è richiesto da quella dichiarazione di cui sopra.

Speriamo che questo aiuti ... o almeno confermi quello che stai cercando di fare. Fatemi sapere se avete altre domande su questo e io elaborerò.

Buona fortuna!

Answer 3

Il codice fornito

CurrentDataSource.Offices.Where(o => o.base_Trades.Any(t => t.Name == "test")) 

dovrebbe funzionare, a patto che o.base_Trades implementa IEnumerable<Trade>. Se o.base_Trades implementa solo IEnumerable, è necessario utilizzare Cast<Trade>() se si è sicuri che tutti gli elementi in o.base_Trades sono del tipo Trade o OfType<Trade>() se potrebbero esserci elementi di altri tipi (incompatibili).

Questo sarebbe quindi simile a questa:

CurrentDataSource.Offices 
    .Where(o => o.base_Trades.Cast<Trade>.Any(t => t.Name == "test")) 

Answer 4

Si prega di non fare questo, quello che vuoi veramente utilizzare una libreria chiamata dinamica linq. http://nuget.org/packages/DynamicLINQ

È possibile archiviare le query come stringhe e supporta query molto complesse. Gli alberi delle espressioni sono un incubo.