Tri dynamic entre entités

Ceci est ma requête, comment utiliser ssortingng comme paramètre orderby?

ssortingng sortColumn="Title"; var items = (from ltem in ctxModel.Items where ltem.ItemID == vId orderby //something here select ltem).Skip(PageSize * PageIndex).Take(PageSize); 

METTRE À JOUR:
Je ne peux pas juste commanderPar le jeu de résultats, parce que je dois d’abord sortinger, et seulement ensuite à la page.

D’autres ont suggéré d’utiliser le lien dynamic ou d’autres bibliothèques. Personnellement , je n’apporterais pas de dépendance à la bibliothèque pour une tâche aussi petite. Mais deux autres chemins que vous pouvez emprunter sont …

  • Utilisez la syntaxe d’ appel d’object et générez votre arborescence d’expression de requête de manière dynamic. Par exemple…

Voir http://blog.cincura.net/229310-sorting-in-iqueryable-using-ssortingng-as-column-name/

Il est important de prendre en compte l’exécution différée dans ce scénario. Vous pouvez créer en toute sécurité votre requête qui retourne un object IQueryable , puis exécuter un sorting de requête d’object sur cet object. Votre requête ne sera exécutée qu’une seule fois, lorsque les données sont réellement consultées.

L’article de blog ci-dessus est un exemple d’utilisation de l’API d’expression pour créer un arbre d’expression que vous pouvez utiliser pour votre OrderBy . Cela semble vraiment compliqué. L’article MSDN peut être une meilleure référence. Voir Comment: utiliser des arbres d’expression pour créer des requêtes dynamics sur MSDN.

Ou

  • Utilisez la route simple et utilisez simplement un commutateur sur le titre pour la requête entière.

Par exemple.

 ItemType items = default(ItemType); switch(sortColumn) { case "Title": { items = ctxModel.Items .Where(i => i.ItemID == vId) .OrderBy( i => i.Title); } break; } 

J’utilise cette aide:

 public static class OrderExt { private static IOrderedQueryable Order(this IQueryable source, ssortingng propertyName, SortDirection descending, bool anotherLevel = false) { var param = Expression.Parameter(typeof(T), ssortingng.Empty); var property = Expression.PropertyOrField(param, propertyName); var sort = Expression.Lambda(property, param); var call = Expression.Call( typeof (Queryable), (!anotherLevel ? "OrderBy" : "ThenBy") + (descending == SortDirection.Descending ? "Descending" : ssortingng.Empty), new[] {typeof (T), property.Type}, source.Expression, Expression.Quote(sort)); return (IOrderedQueryable)source.Provider.CreateQuery(call); } } 

appeler l’assistant, par exemple procédez comme suit:

 ssortingng sort = HttpContext.Current.Request.QuerySsortingng["sort"]; var products = _productRepository.OrderBy(sort, SortDirection.Ascending); 

Voici une autre alternative, EntitySorter . Permet un peu ce que LINQ dynamic fait avec les chaînes, mais englobe l’opération dans un object, comme avec le modèle d’object de requête . Il permet à la fois de sortinger par chaînes et par type de constructions sûres. Voici quelques exemples:

 // Ways of defining an entity sorter // 1. Using ssortingngs: IEntitySorter sorter = EntitySorter .OrderBy("Address.City") .ThenByDescending("Id"); // 2. Defining a sorter with lambda's IEntitySorter sorter = EntitySorter .OrderByDescending(p => p.Name) .ThenBy(p => p.Id) .ThenByDescending(p => p.Address.City); // 3. Using a LINQ query IEntitySorter sorter = from person in EntitySorter.AsQueryable() orderby person.Name descending, person.Address.City select person; // And you can pass a sorter from your presentation layer // to your business layer, and you business layer may look // like this: static Person[] GetAllPersons(IEntitySorter sorter) { using (var db = ContextFactory.CreateContext()) { IOrderedQueryable sortedList = sorter.Sort(db.Persons); return sortedList.ToArray(); } } 

Vous pouvez trouver le code ici .

Apparemment, les autres allusions à Dynamic Linq ne sont pas assez claires. Laissez-moi jeter un peu de lumière ..

L’utilisation de Dynamic Linq n’indique pas nécessairement la nécessité d’une dépendance d’assemblage.

Si je ne me trompe pas, Dynamic Linq est contenu dans un fichier source, inclus dans les exemples C # que tout le monde devrait au moins avoir consulté au cours des 3 dernières années, et peut facilement être inséré dans un projet et mis en espace pour éviter les collisions, fournissant ainsi des services de renforcement de l’expression pouvant être utilisés partout où le besoin s’en fait sentir.

Je considère que la possibilité de construire en toute sécurité une expression à partir d’une ssortingng raisonnablement arbitraire, qui peut facilement être construite à la volée, constitue le meilleur exemple de “dynamic”.

Considérer:

  var query = northwind.Products .Where("CategoryID = 3 AND UnitPrice > 3") .OrderBy("SupplierID"); 

Cette requête donne l’impression que vous utilisez une liaison de données personnalisée et / ou ObjectDataSource. Quoi qu’il en soit, il existe un moyen de le faire en utilisant une méthode d’extension qui prend une expression de sorting et ajoute de manière dynamic un appel (expression) à OrderBy () à la requête linq. J’ai documenté comment dans un article de blog il y a quelque temps, ce qui faisait par hasard partie de cette question SO . Si vous avez besoin de plus que cela, vous pouvez utiliser linq dynamic, qui est assez bien documenté par scottgu.

EDIT: utiliser la méthode d’extension lui donnerait l’air

 ssortingng sortColumn="Title"; var items = (from ltem in ctxModel.Items where ltem.ItemID == vId select ltem).Skip(PageSize * PageIndex).Take(PageSize).OrderBy(sortColumn);