using System;

​

public class Program

{

    static IOrderedQueryable<T> ApplyOrder<T>(IQueryable<T> source, string property, string methodName)

    {

        ParameterExpression arg = Expression.Parameter(typeof(T), "x");

        Expression expr = arg;

        foreach (string prop in property.Split('.'))

        {

            // use reflection (not ComponentModel) to mirror LINQ

            expr = Expression.PropertyOrField(expr, prop);

        }

​

        Type delegateType = typeof(Func<, >).MakeGenericType(typeof(T), expr.Type);

        LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);

        return (IOrderedQueryable<T>)typeof(Queryable).GetMethods().Single(method => method.Name == methodName && method.IsGenericMethodDefinition && method.GetGenericArguments().Length == 2 && method.GetParameters().Length == 2).MakeGenericMethod(typeof(T), expr.Type).Invoke(null, new object[]{source, lambda});

    }

}

​

public static IOrderedQueryable<TSource> OrderBy<TSource>(this IQueryable<TSource> query, string propertyName, string sortDirection, bool isContinuation = false)

{

    var entityType = typeof(TSource);

    // Create x=>x.PropName

    var propertyInfo = entityType.GetProperty(propertyName);

    if (propertyInfo.DeclaringType != entityType)

    {

        propertyInfo = propertyInfo.DeclaringType.GetProperty(propertyName);

    }

​

    // If we try to order by a property that does not exist in the object return the list

    if (propertyInfo == null)

    {

        return (IOrderedQueryable<TSource>)query;

    }

​

    var arg = Expression.Parameter(entityType, "x");

    var property = Expression.MakeMemberAccess(arg, propertyInfo);

    var selector = Expression.Lambda(property, new ParameterExpression[]{arg});

    var methodName = sortDirection.ToUpper() == "DESC" ? "OrderByDescending" : "OrderBy";

    if (isContinuation)

    {

        methodName = sortDirection.ToUpper() == "DESC" ? "ThenByDescending" : "ThenBy";

    }

​

    // Get System.Linq.Queryable.OrderBy() method.

    var method = typeof(Queryable).GetMethods().Where(m => m.Name == methodName && m.IsGenericMethodDefinition).Where(m => m.GetParameters().ToList().Count == 2) // ensure selecting the right overload

    .Single();

    //The linq's OrderBy<TSource, TKey> has two generic types, which provided here

    MethodInfo genericMethod = method.MakeGenericMethod(entityType, propertyInfo.PropertyType);

    /* Call query.OrderBy(selector), with query and selector: x=> x.PropName

              Note that we pass the selector as Expression to the method and we don't compile it.

              By doing so EF can extract "order by" columns and generate SQL for it. */

    return (IOrderedQueryable<TSource>)genericMethod.Invoke(genericMethod, new object[]{query, selector});

}