Sorting IEnumerable using LINQ

Question

There are many similar questions on SO, but I'm not seeing one that fits my circumstances...

I'm wondering why this doesn't work to sort an IEnumerable of Premise objects:

sortedPremiseList = from p in premiseList
                 orderby (string.Format("{0} {1}", orderBy, sortOrder))
                  select p;

I'm passing in a valid p.property for the orderBy argument and "ascending" or "descending" for the sortOrder argument

And if I can't 'dynamicize' my LINQ in a limited fashion like this, what alternative is there beside a big ugly Switch statement or something like that?

Many thanks for your time.

Shouldn't the parameters to string.Format be p.OrderBy and p.sortOrder? — Marcelo Zabani, Dec 28 '11 at 04:36
Dynamic LINQ OrderBy is given for IEnumerable by Marc Gravell in [this answer][1]. [1]: http://stackoverflow.com/questions/41244/dynamic-linq-orderby — hypermush, Dec 28 '11 at 04:37
Seems like the best solution for me is to use Marc's code as suggested by hypermush. — theog, Dec 28 '11 at 20:55

score 2 · Answer 1 · answered Dec 28 '11 at 04:34

2

I think you're combining query notation, and dot notation. For this, try sticking to just dot notation:

sortedPremiseList = premiseList
           .OrderBy(p => string.Format("{0} {1}", p.orderBy, p.sortOrder));

answered Dec 28 '11 at 04:34

Adam Rackis

79,454
49
255
377

score 1 · Answer 2 · answered Sep 02 '12 at 19:14

I think I understand what you are asking for here. You want to construct the LINQ query from string arguments

Okay. I like a challenge.

IComparable GetPropValue( object src, string propName )
{
  return (IComparable)src.GetType( ).GetProperty( propName ).GetValue( src, null );
}

IEnumerable<Premise> SortMyPremises(IEnumerable<Premise> premises, string propertyName, string ascendingOrDescending) 
{
  return ascendingOrDescending = "ascending" 
    ? premises.OrderBy(p => GetPropValue(p, propertyName)) 
    : premises.OrderByDescending(p => GetPropValue(p, propertyName));
}

The reason the way you wrote it doesn't work, is that the LINQ expression is transformed into code at compile-time, and the string you are passing it is not evaluated until run-time.

score 1 · Answer 3 · answered Dec 28 '11 at 04:35

1

I think you need to reference p inside your string.Format() call, like this:

sortedPremiseList = from p in premiseList
    orderby (string.Format("{0} {1}", p.orderBy, p.sortOrder))
    select p;

answered Dec 28 '11 at 04:35

Sergey Kalinichenko

675,664
71
998
1,399

score 0 · Answer 4 · answered Apr 16 '13 at 21:00

This worked for me:

public static IEnumerable<TEntity> OrderBy<TEntity>(this IEnumerable<TEntity> source, string orderByProperty,
                            bool desc)
        {
            string command = desc ? "OrderByDescending" : "OrderBy";
            var type = typeof(TEntity);
            var property = type.GetProperty(orderByProperty);
            var parameter = Expression.Parameter(type, "p");
            var propertyAccess = Expression.MakeMemberAccess(parameter, property);
            var orderByExpression = Expression.Lambda(propertyAccess, parameter);
            var resultExpression = Expression.Call(typeof(Queryable), command, new Type[] { type, property.PropertyType },
                                          source.AsQueryable().Expression, Expression.Quote(orderByExpression));
            return source.AsQueryable().Provider.CreateQuery<TEntity>(resultExpression);
        }

Sorting IEnumerable using LINQ

4 Answers4