1
votes

Comment agréger les commandes en c #?

J'ai donc une fonction comme ci-dessous qui prend dans une liste d'objets et continue de les inclure dans ma chaîne de requête. Cela fonctionne très bien.

orderItems(x => x.Item1, x => x.Item2)

Mais ce que je veux faire, c'est aussi d'agréger les OrderBys. C'est là que je rencontre des problèmes. Le problème que j'ai est que l'on doit utiliser OrderBy puis utiliser ThenBy sur la même ligne. J'ai essayé d'utiliser un ordre d'utilisation du premier élément de la boucle for, puis de l'utiliser ensuite. Le problème que je rencontre est que pour que la commande soit activée, la commande doit être exécutée sur la même ligne d'objet.

var usedOrderBy = true;
        foreach (var orderBy in orderBys)
        {
            if (usedOrderBy)
            {
                query = query.OrderBy(orderBy);

                usedOrderBy = true;
            }
            else
            {
                query = query.ThenBy(orderBy); // <-- Can not locate thenby
            }
        }

any ides.

Je ne peux pas faire p >

query.OrderBy(orderBy).ThenBy

Je veux passer comme

query = includeExpressions.Aggregate(query, (current, include) => current.Include(include));

c# entity-framework aggregate

3 commentaires

Peut-être que cela aidera Commander par et ensuite en utilisant LINQ

Supprimez le usedOrderBy et disposez à la place d'une variable stockant les résultats du OrderBy (je ne suis pas sûr du type OTTOMH - probablement IOrderedQueryable ). Ensuite, à l'intérieur de la boucle, vérifiez si la variable est null ou non (plutôt que de vérifier le bool .

Vous pouvez visiter l'arborescence des expressions pour voir si elle contient un appel de méthode "OrderBy".

3 Réponses :

2
votes

Le problème est dans le type de variable query . ThenBy est la méthode d'extension qui peut être appliquée à System.Linq.IOrderedEnumerable ou System.Linq.IOrderedQueryable donc vous ne pouvez pas faire simplement

IEnumerable<Point> points = GetPoints();
var orderedPoints = points.OrderBy(p => p.X);
orderedPoints = orderedPoints.ThenBy(p => p.Y);

Vous devriez avoir une variable supplémentaire pour le résultat pré-commandé pour résoudre votre scénario comme dans l'exemple ci-dessous:

IEnumerable<Point> points = GetPoints();
points = points.OrderBy(p => p.X);
points = points.ThenBy(p => p.Y);

0 commentaires

0
votes

Cochez ceci

   var orderByList = new List<Expression<Func<TEntity, object>>>();
            Expression<Func<TEntity,object>> orderBy1 = x => x.Id;
            Expression<Func<TEntity, object>> orderBy2 = x => x.ToString();
            Expression<Func<TEntity, object>> orderBy3 = x => x.Id;
            orderByList.Add(orderBy1);
            orderByList.Add(orderBy2);
            orderByList.Add(orderBy3);

            var resultOrderedQueryable = orderByList.Aggregate<Expression<Func<TEntity, object>>, IOrderedQueryable<TEntity>>(null, (current, orderBy) => current != null ? current.ThenBy(orderBy) : query.OrderBy(orderBy));

1 commentaires

Je n'ai pas pensé à cela, cela fonctionne, j'ai ajusté la réponse pour inclure orderby pour thenby thx.

0
votes

Votre requête fonctionnera si elle peut avoir la valeur initiale de OrderBy . Ensuite, vous pouvez enchaîner ThenBy's. Comme mentionné, ThenBy nécessite un IOrderedEnumerable (ou IOrderedQueryable ) avant d'attacher des clauses ThenBy :

Votre code ressemblera à ceci:

IOrderedQueryable<T> orderedQuery = null;
for(int temp = 0; temp < orderBys.Count; temp++)
{
    if(temp == 0)
        orderedQuery = query.OrderBy(orderBys[temp]);

    else orderedQuery = orderedQuery.ThenBy(orderBys[temp]);  
}
query = orderedQuery ?? query;

Référence: Comment générer un nombre dynamique de clauses ThenBy dans une spécification

0 commentaires