How to use dynamically generated OrderBy in LINQ?

Question

Based on API, I can have multiple parameters which can be used in order by. There is a function which creates a dynamic order by parameter as a string. I want to use this in .OrderBy but not sure how to do this.

API Call:

{{url}}?keyword=singer&page=12&size=5&sortby=LastName&sortby=FirstName

Code:

public CallCenterPageResult<CallCenterCustomerSummary> GetCustomers(int page, int pageSize, IEnumerable<SortParameter> sortParameters, string keyword)
{
    using (var ctx = new EFCallCenterContext())
    {
        var customerDetails = ctx.CallCenterCustomers
                                 .Where(ccs => ccs.IsDeleted == false && (ccs.FirstName.Contains(keyword) || ccs.LastName.Contains(keyword) || ccs.Phone.Contains(keyword)))
                                 .OrderBy(sortParameters.ToOrderBy()) // "LastName ASC, FirstName ASC"
                                 .Skip(pageSize * (page - 1)).Take(pageSize)
                                 .ToList();

        return customerDetails;
    }
}

Extension Method to get order by:

static class RepositoryExtensions
{
    public static string ToOrderBy(this IEnumerable<SortParameter> parameters)
    {
        return string.Join(", ", parameters.Select(p => p.SortBy + (p.Descending ? " DESC" : " ASC")));
    }
}

Output:

"LastName ASC, FirstName ASC"

Extension method to accept dynamic LINQ:

public static class Extension
{
    public static IOrderedQueryable<T> OrderBy<T>(this IQueryable<T> source, string property)
    {
        return ApplyOrder<T>(source, property, "OrderBy");
    }
    public static IOrderedQueryable<T> OrderByDescending<T>(this IQueryable<T> source, string property)
    {
        return ApplyOrder<T>(source, property, "OrderByDescending");
    }
    public static IOrderedQueryable<T> ThenBy<T>(this IOrderedQueryable<T> source, string property)
    {
        return ApplyOrder<T>(source, property, "ThenBy");
    }
    public static IOrderedQueryable<T> ThenByDescending<T>(this IOrderedQueryable<T> source, string property)
    {
        return ApplyOrder<T>(source, property, "ThenByDescending");
    }
    static IOrderedQueryable<T> ApplyOrder<T>(IQueryable<T> source, string property, string methodName)
    {
        var props = property.Split('.');
        var type = typeof(T);
        var arg = Expression.Parameter(type, "x");
        Expression expr = arg;
        foreach (string prop in props)
        {
            // use reflection (not ComponentModel) to mirror LINQ
            PropertyInfo pi = type.GetProperty(prop);
            expr = Expression.Property(expr, pi); // Errors out here.
            type = pi.PropertyType;
        }
        var delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
        var lambda = Expression.Lambda(delegateType, expr, arg);

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

Error:

System.ArgumentNullException: Value cannot be null.
Parameter name: property

Scrren shot:

This is the first time working with this complex query so not sure how to do this. I can add more info if needed.

Answer 1

It looks like the error occurs because pi is null. And it is null because, I would assume, the class standing in for the T generic doesn't have a property named LastName ASC, FirstName ASC. I would try something like the following:

var props = property.Split(",");
... //this code stays the same
foreach(string prop in props) {
    var propNameAndDirection = prop.Split(" ");
    PropertyInfo pi = type.GetProperty(propNameAndDirection[0]);
    ... //continue as necessary, using propNameAndDirection[1] 
    ... //to decide OrderBy or OrderByDesc call

Hopefully this sets you in the right direction.

Answer 2

After some trial and error, I am able to find an answer.

Tested with followings:

.OrderBy("LastName ASC, FirstName ASC")
.OrderBy("LastName ASC")
.OrderBy("LastName ASC,FirstName DESC")

Linq:

public CallCenterPageResult<CallCenterCustomerSummary> GetCustomers(int page, int pageSize, IEnumerable<SortParameter> sortParameters, string keyword)
{
    using (var ctx = new EFCallCenterContext())
    {
        var customerDetails = ctx.CallCenterCustomers
                                 .Where(ccs => ccs.IsDeleted == false && (ccs.FirstName.Contains(keyword) || ccs.LastName.Contains(keyword) || ccs.Phone.Contains(keyword)))
                                 .OrderBy(o => o.Equals(sortParameters.ToOrderBy()))
                                 .Skip(pageSize * (page - 1)).Take(pageSize)
                                 .ToList();

        return customerDetails;
    }
}

Helper Class:

public static class OrderByHelper
{
    public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> enumerable, string orderBy)
    {
        return enumerable.AsQueryable().OrderBy(orderBy).AsEnumerable();
    }

    public static IQueryable<T> OrderBy<T>(this IQueryable<T> collection, string orderBy)
    {
        foreach (var orderByInfo in ParseOrderBy(orderBy))
        {
            collection = ApplyOrderBy(collection, orderByInfo);
        }

        return collection;
    }

    private static IQueryable<T> ApplyOrderBy<T>(IQueryable<T> collection, OrderByInfo orderByInfo)
    {
        var props = orderByInfo.PropertyName.Split('.');
        var type = typeof (T);

        var arg = Expression.Parameter(type, "x");
        Expression expr = arg;
        foreach (var prop in props)
        {
            var pi = type.GetProperty(prop);
            expr = Expression.Property(expr, pi);
            type = pi.PropertyType;
        }
        var delegateType = typeof (Func<,>).MakeGenericType(typeof (T), type);
        var lambda = Expression.Lambda(delegateType, expr, arg);
        string methodName;

        if (!orderByInfo.Initial && collection is IOrderedQueryable<T>)
        {
            methodName = orderByInfo.Direction == SortDirection.Ascending ? "ThenBy" : "ThenByDescending";
        }
        else
        {
            methodName = orderByInfo.Direction == SortDirection.Ascending ? "OrderBy" : "OrderByDescending";
        }

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

    private static IEnumerable<OrderByInfo> ParseOrderBy(string orderBy)
    {
        if (string.IsNullOrEmpty(orderBy))
        {
            yield break;
        }

        var items = orderBy.Split(',');
        var initial = true;
        foreach (var item in items)
        {
            var pair = item.Trim().Split(' ');

            if (pair.Length > 2)
            {
                throw new ArgumentException(
                    $"Invalid OrderBy string '{item}'. Order By Format: Property, Property2 ASC, Property2 DESC");
            }

            var prop = pair[0].Trim();

            if (string.IsNullOrEmpty(prop))
            {
                throw new ArgumentException(
                    "Invalid Property. Order By Format: Property, Property2 ASC, Property2 DESC");
            }

            var dir = SortDirection.Ascending;

            if (pair.Length == 2)
            {
                dir = "desc".Equals(pair[1].Trim(), StringComparison.OrdinalIgnoreCase)
                    ? SortDirection.Descending
                    : SortDirection.Ascending;
            }

            yield return new OrderByInfo {PropertyName = prop, Direction = dir, Initial = initial};

            initial = false;
        }
    }

    private class OrderByInfo
    {
        public string PropertyName { get; set; }
        public SortDirection Direction { get; set; }
        public bool Initial { get; set; }
    }

    private enum SortDirection
    {
        Ascending = 0,
        Descending = 1
    }

Referances:

Dynamic LINQ OrderBy on IEnumerable<T>

http://aonnull.blogspot.com/2010/08/dynamic-sql-like-linq-orderby-extension.html

Answer 3

If I understood the problem correctly.

Expression<Func<TEntity, TKey>> genericParameter = null;

genericParameter = x => x.foo;

var customerDetails = ctx.CallCenterCustomers
                                 .Where(ccs => ccs.IsDeleted == false && (ccs.FirstName.Contains(keyword) || ccs.LastName.Contains(keyword) || ccs.Phone.Contains(keyword)))
                                 .OrderBy(genericParameter)