Nesting PredicateBuilder predicati: f 'Il parametro '' non era legato in LINQ specificato to Entities interrogare espressione'

Question

sto costruendo predicati con classe PrediateBuilder di LinqKit a dinamicamente filtri di configurazione e voglio combinare uno nidificato all'altro.

Ho letto questo (http://www.albahari.com/nutshell/predicatebuilder.aspx):

Ecco il mio codice:

// The main predicate. 
var mainPredicate = PredicateBuilder.True<Document>(); 

// ... some other conditions to the main predicate here ... 

// The inner predicate (combined conditions using OR). 
var innerPredicate = PredicateBuilder.False<Document>(); 

foreach (var period in periods) 
{ 
    var p = period; 
    innerPredicate = 
     innerPredicate.Or(
      d => 
      (d.Date >= p.DateFrom && d.Date <= p.DateTo)); 
} 

mainPredicate = mainPredicate.And(innerPredicate); 

documents = this.ObjectSet.AsExpandable().Where(mainPredicate).ToList(); 

sto combinando i miei due predicati proprio come è spiegato nella documentazione. Tuttavia, ottengo questa eccezione:

Il parametro 'f' non era vincolato nel LINQ specificato entità espressione interrogazione

ho pensato che il predicato interno deve essere ampliato prima di mescolarla con il predicato principale, così ho cambiato il mio codice si combinano per aggiungere una chiamata al metodo del predicato interna Expand come questo:

mainPredicate = mainPredicate.And(innerPredicate.Expand()); 

Ma ho la ex fa la stessa eccezione.

L'unica differenza nel mio codice contro la documentazione è che io dinamicamente costruire il mio predicato nidificato utilizzando un ciclo foreach. Semplicemente non so come possa influenzare negativamente l'espressione risultante.

• Cosa c'è di sbagliato nel mio codice?

• Come posso eseguire il debug di questo?

• Da dove proviene il parametro f? Come viene generato? Perché è problematico nel mio caso?

• C'è qualche tipo di visualizzatore di espressioni di qualche tipo che potrebbe aiutarmi a vedere effettivamente cosa c'è di sbagliato nell'espressione risultante? Perché il corpo dell'espressione è difficile da leggere.

Answer 1

Infine, ho trovato un modo per evitare di combinare più predicati nell'albero delle espressioni principali.

Dato che ogni predicato rappresenta un filtro diverso e voglio il, filtro combinato finale sia una serie di deve-essere rispettato condizioni, possiamo dire che ciascuno dei predicati deve tornare vero per la predicato finale per restituire vero.

Affinché funzioni, i predicati devono essere combinati con AND. Quindi, la query SQL risultante deve essere simile a questa:

predicate1 AND predicate2 AND predicate3 ...

Un modo migliore per combinare questi predicati con AND vale a catena Where operatori di query alla query finale, come questo:

var documents = this.ObjectSet.AsExpandable() 
    .Where(mainPredicate) 
    .Where(otherPredicate) 
    .Where(yetAnotherPredicate) 
    .ToList(); 

La query SQL risultante combinare ciascuna di tali predicati con AND. Questo è proprio quello che volevo fare.

È più semplice che scavalcare un albero di espressioni da solo.