Prise en compte avec NHibernate + Linq + Futur

Je veux faire de la pagination avec NHibernate lors de l'écriture d'une requête Linq. Il est facile de faire quelque chose comme ceci:

return session.Query<Payment>()
    .OrderByDescending(payment => payment.Created)
    .Skip((page - 1)*pageSize)
    .Take(pageSize)
    .ToArray();

Mais avec ce je ne pas obtenir aucune info sur le nombre total d'éléments. Et si je fais juste un simple .Count(), qui va générer un nouvel appel à la base de données.

J'ai trouvé cette réponse qui résolu par l'utilisation future. Mais il utilise des Critères. Comment puis-je faire cela avec Linq?

Session D'Utilisation.QueryOver au lieu de cela est qu'il économise de l'intellisense et "compileability", et il est un SelectCount méthode. Si vous avez besoin je peux fournir des détails exemple d'utilisation
Oui s'il vous plaît, QueryOver semble bien fonctionner aussi!
(J'ai repéré une erreur dans ma solution et l'a supprimé pour éviter toute confusion. Je vais poster la version fixe peu de temps)

InformationsquelleAutor Allrameest | 2011-02-10

La difficulté avec l'aide de contrats à Terme avec LINQ, c'est que des opérations comme le Comte exécuter immédiatement.

Comme @vandalo découvert, Count() après ToFuture() exécute les Compter dans la mémoire, ce qui est mauvais.

La seule façon d'obtenir le comte, dans un avenir requête LINQ est d'utiliser GroupBy dans un invariant de terrain. Un bon choix serait quelque chose qui est déjà une partie de vos filtres (comme un "est actif" de la propriété)

Voici un exemple en supposant que vous avez une propriété de ce type de Paiement:

//Create base query. Filters should be specified here.
var query = session.Query<Payment>().Where(x => x.IsActive == 1);
//Create a sorted, paged, future query,
//that will execute together with other statements
var futureResults = query.OrderByDescending(payment => payment.Created)
                         .Skip((page - 1) * pageSize)
                         .Take(pageSize)
                         .ToFuture();
//Create a Count future query based on the original one.
//The paged query will be sent to the server in the same roundtrip.
var futureCount = query.GroupBy(x => x.IsActive)
                       .Select(x => x.Count())
                       .ToFutureValue();
//Get the results.
var results = futureResults.ToArray();
var count = futureCount.Value;

Bien sûr, l'alternative est de faire deux allers-retours, ce qui n'est pas mauvais de toute façon. Vous pouvez toujours réutiliser l'original IQueryable, ce qui est utile lorsque vous souhaitez faire un échange dans une couche de haut niveau:

//Create base query. Filters should be specified here.
var query = session.Query<Payment>();
//Create a sorted, paged query,
var pagedQuery = query.OrderByDescending(payment => payment.Created)
                      .Skip((page - 1) * pageSize)
                      .Take(pageSize);
//Get the count from the original query
var count = query.Count();
//Get the results.
var results = pagedQuery.ToArray();

Mise à jour (2011-02-22): j'ai écrit un post de blog sur cette question, et une bien meilleure solution.

la méthode d'extension dans votre blog est une très belle solution

InformationsquelleAutor Diego Mijelshon

4

Le blog suivant est une mise en œuvre de ToFutureValue qui fonctionne avec LINQ.

http://sessionfactory.blogspot.com.br/2011/02/getting-row-count-with-future-linq.html

Il a une petite erreur sur la ligne suivante qui doit être changé à partir de ce.
```
var provider = (NhQueryProvider)source.Provider;
```
À ceci:
```
var provider = (INhQueryProvider)source.Provider;
```
Appliquer après le changement que vous pouvez utiliser que les requêtes de cette façon:
```
var query = session.Query<Foo>();
var futureCount = query.ToFutureValue(x => x.Count());
var page = query.Skip(pageIndex * pageSize).Take(pageSize).ToFuture();
```
InformationsquelleAutor Carlos Beppler
1
```
var query = Session.QueryOver<Payment>()
    .OrderByDescending(payment => payment.Created)
    .Skip((page -1 ) * pageSize)
    .Take(pageSize)
```
C'est quelque chose que je viens de découvrir que le Linq to NH gère très bien, le ToRowCountQuery supprime prendre/saut à partir de la requête et un avenir de nombre de lignes.
```
var rowCount = query.ToRowCountQuery().FutureValue<int>();

var result = query.Future();

var asArray = result.ToArray();
var count = rowCount.Value();
```
- Fonctionne bien avec SQL Server, mais pas avec SQL Server Compact Edition... 🙁 Système d'.Les données.SqlServerCe.SqlCeException : Il y a eu une erreur lors de l'analyse de la requête. [ Jeton numéro de ligne = 2,Jeton de décalage de ligne = 1,Jeton dans l'erreur = SELECT ]
- La question spécifiquement demandé une linq solution, pas QueryOver.
- Étrangement, ToRowCountQuery semble supprimer les groupements... stackoverflow.com/questions/8012966/...
InformationsquelleAutor genonist
-6

Ok, il semble que ce devrait être le travail dans votre cas, mais j'ai pas testé:
```
return session.QueryOver<Payment>()
  .Skip((page - 1) * pageSize)
  .Take(pageSize)
  .SelectList(r => r.SelectCount(f => f.Id))
  .List<object[]>().First();
```
Tester d'abord avant de upvoting 😉

UPD: désolé, comme je vous comprends maintenant, vous avez besoin pour obtenir le nombre de tous les éléments. Ensuite, vous devez exécuter la requête sans pagination:
```
return session.QueryOver<Payment>()
  .SelectList(r => r.SelectCount(f => f.Id))
  .List<object[]>().First();
```
- Ce n'est PAS ce qu'il fallait.
- Mijelshon, wow! mon rep est 666 maintenant, merci! 🙂
- Aucune de ces requêtes vont faire ce qui est nécessaire. Obtenir le paginé ensemble de l'objet + obtenir un décompte du nombre total d'objets qui satisfont aux critères.
- Je pense que c'est clairement indiqué dans la question de l'utilisation NHibernate + Linq au lieu de QueryOver.
InformationsquelleAutor Genius

Vous devez vous connecter pour publier un commentaire.