C# linq and sorting

Question

With linq I want to use order by with specific column but I need two switches because i don't know how to use desc or asc in one

public class CustomersRepository : RepositoryBase<Customers>
        {
            public List<Customers> GetAll(CustomersProperties property, SortEnum sortEnum, int page, int limit)
            {
                var query = _context.Set<Customers>();

                switch (sortEnum)
                {
                    case SortEnum.Ascending:
                        switch (property)
                        {
                            case CustomersProperties.Name:
                                query = query.OrderBy(x => x.Name);
                                break;
                            case CustomersProperties.Surname:
                                query = query.OrderBy(x => x.Lastname);
                                break;
                            default:
                                throw new ArgumentOutOfRangeException("property");
                        }
                        break;
                    case SortEnum.Descending:
                        break;
                    default:
                        throw new ArgumentOutOfRangeException("sortEnum");
                }

                return query.Skip(page * limit)
                                .Take(limit).ToList();
            }
        }

Is it possible to do without two switch cases?

FYI, query.OrderBy(x => x.Name); does nothing: you need query = query.OrderBy(x => x.Name); — Blorgbeard
– Blorgbeard, Commented Jan 28, 2014 at 19:31

D Stanley · Accepted Answer · 2014-01-28 19:40:27Z

2

Be aware that query.OrderBy(x => x.Name); does not do anything since the sorted collection is returned from OrderBy, and you're not capturing that return.

That said, there's not a way to "dynamically" choose the direction in Linq. However, a conditional switch would be a little cleaner. Another option would be to capture the sort expression in a variable:

Expreccion<Func<Customers, string>> propExp;
switch (property)
{
    case CustomersProperties.Name:
        propExp = ((Customers)x => x.Name)            
        break;
    case CustomersProperties.Surname:
        propExp = ((Customers)x => x.Lastname);
        break;
    default:
        throw new ArgumentOutOfRangeException("property");
}

query = sortEnum == SortEnum.Ascending 
                  ? query.OrderBy(propExp);
                  : query.OrderByDescending(propExp);

edited Jan 28, 2014 at 19:40

answered Jan 28, 2014 at 19:35

D Stanley

153k12 gold badges189 silver badges257 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Blorgbeard · Accepted Answer · 2014-01-28 19:43:52Z

1

You could make your own overload, something like this:

public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(
    this IQueryable<TSource> source,
    Expression<Func<TSource, TKey>> keySelector, SortEnum sort) {
    switch (sort) {
        case SortEnum.Ascending:
            return source.OrderBy(keySelector);
        case SortEnum.Descending:
            return source.OrderByDescending(keySelector);
        default:
            throw new ArgumentOutOfRangeException("sort");
    }
}


// later on..
query = query.OrderBy(x => x.LastName, sortEnum);

edited Jan 28, 2014 at 19:43

answered Jan 28, 2014 at 19:36

Blorgbeard

104k50 gold badges237 silver badges276 bronze badges

2 Comments

MarcinJuraszek Over a year ago

That's not LINQ to Objects, so I don't think using IEnumerable and IOrderedEnumerable is a good choice.

Blorgbeard Over a year ago

@MarcinJuraszek Good point, changed to IQueryable. The concept remains clear anyway, I hope..

MarcinJuraszek · Accepted Answer · 2014-01-28 19:38:57Z

You can prepare sortProperty Expression first and then use it with either OrderBy or OrderByDescending:

public List<Customers> GetAll(CustomersProperties property, SortEnum sortEnum, int page, int limit)
{
    var query = _context.Set<Customers>();

    Expression<Func<Customers, string>> sortProperty;
    switch (property)
    {
        case CustomersProperties.Name:
            sortProperty = x => x.Name;
            break;
        case CustomersProperties.Surname:
            sortProperty = x => x.Lastname;
            break;
        default:
            throw new ArgumentOutOfRangeException("property");
    }

    switch (sortEnum)
    {
        case SortEnum.Ascending:
            query = query.OrderBy(sortProperty);
            break;
        case SortEnum.Descending:
            query = query.OrderByDescending(sortProperty);
            break;
        default:
            throw new ArgumentOutOfRangeException("sortEnum");
    }

    return query.Skip(page * limit)
                    .Take(limit).ToList();
}

Collectives™ on Stack Overflow

C# linq and sorting

3 Answers 3

Comments

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related