LINQ Fluent NHibernate .Contains() non funziona in QueryOver <>, ma lavora in Query <>

Question

Utilizzando FNH, sto cercando di recuperare categorie, utilizzando la seguente:

_session.QueryOver<Data.Model.Category>() 
            .Where(c => tourCreateRequest.Categories.Contains(c.CategoryId)) 
            .List() 
            .Select(_categoryMapper.CreateCategory) 
            .ToList(); 

ma ottengo un errore alla le .Contains() metodo:

metodo riconosciuto chiamata: System.Collections.Generic.ICollection`1 [[System.Int64, mscorlib, versione = 4.0.0.0, Culture = neutral, PublicKeyToken = b77a5c561934e089]]: B oolean Contains (Int64)

Perché sto ricevendo quell'errore, cosa c'è che non va?

Sono passato attraverso alcuni post, quindi ho cambiato la mia query in (sotto), e questo funziona con Query <>.

_session.Query<Data.Model.Category>() 
            .Where(c => tourCreateRequest.Categories.Contains(c.CategoryId)) 
            .ToList() 
            .Select(_categoryMapper.CreateCategory) 
            .ToList(); 

ho pensato QueryOver <> è l'ultima e più grande e dovrebbe essere usato al posto di Query <>.

Qual è il problema con il modo in cui sto usando QueryOver <> come mostrato sopra?

Answer 1

Ho trovato la risposta. Grazie alla posta a: NHibernate using QueryOver with WHERE IN

var categories = _session.QueryOver<Data.Model.Category>() 
            .WhereRestrictionOn(c => c.CategoryId).IsIn(ArrayofCategoryIds) 
            .List() 
            .Select(_categoryMapper.CreateCategory) 
            .ToList(); 

ho dovuto usare il WhereRestrictionOn()

Answer 2

Questo è problema tangenzialmente correlato e questo sembrava il posto migliore per metterlo.

_session.Query<SomeType>.Where(t => someEnumerable.Contains(t)) 

non funzionava.

Nel mio caso someEnumerable NON era un List<SomeType>, ma piuttosto un HashSet<SomeType>. Apparentemente, NH vuole davvero che sia una lista. Quindi, l'ho fatto invece e ha funzionato.

var someEnumerableList = someEnumerable.ToList(); 
_session.Query<SomeType>.Where(t => someEnumerableList.Contains(t) 

Inoltre, FWIW, ho avuto l'impressione che Query<T> era il nuovo modo preferito per andare e che QueryOver<T> era il modo meno preferito, perché Query<T> rendimenti IQueryable, il che significa che dovrebbe essere un po 'più facile per testare, e teoricamente si scambiano gli ORM.