using System;

using System.Collections.Generic;

using System.Linq;

using System.Linq.Expressions;

using System.Web.UI.WebControls;

public class Program

{

    public static void Main()

    {

        IEnumerable<Order> orders = new[]

        {

            new Order

            {

                CustomerInfo = new Customer

                {

                    FirstName = "B"

                }

            },

            new Order

            {

                CustomerInfo = new Customer

                {

                    FirstName = "A"

                }

            }

        };

        orders = orders.OrderBy<Order>("FirstName", SortDirection.Ascending);

    }

}

​

public class Order

{

    public Int32 OrderID{ get; set; }

    public String OrderNumber { get; set; }

    public Customer CustomerInfo { get; set;}

}

public class Customer

{

    public Int64 CustomerNumber { get; set; }

    public String FirstName { get; set; }

    public String  LastName { get; set; }

    public String Phone { get; set; }

}

​

public static class SortExpressionBuilder<T>

{

    private static IDictionary<SortDirection, ISortExpression> directions = 

            new Dictionary<SortDirection, ISortExpression>

    {

        { SortDirection.Ascending, new OrderByAscendingSortExpression() },

        { SortDirection.Descending, new OrderByDescendingSortExpression() }

    };

​

    interface ISortExpression

    {

        Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> GetExpression();

    }

​

    class OrderByAscendingSortExpression : ISortExpression

    {

        public Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> GetExpression()

        {

            return (c, f) => c.OrderBy(f);

        }

    }

​

    class OrderByDescendingSortExpression : ISortExpression

    {

        public Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> GetExpression()

        {

            return (c, f) => c.OrderByDescending(f);

        }

    }

​

    public static Func<IEnumerable<T>, Func<T, object>,  IEnumerable<T>> CreateExpression(SortDirection direction)

    {

        return directions[direction].GetExpression();

    }

}

​

static class Extensions

{

    public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> collection, 

       string columnName, SortDirection direction)

    {

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

        Expression property = Expression.Property(param, columnName);       // x.ColumnName

        Func<T, object> lambda = Expression.Lambda<Func<T, object>>(        // x => x.ColumnName

                Expression.Convert(property, typeof(object)),

                param)

            .Compile();

        Func<IEnumerable<T>, Func<T, object>, IEnumerable<T>> expression = SortExpressionBuilder<T>.CreateExpression(direction);

        IEnumerable<T> sorted = expression(collection, lambda);

        return sorted;

    }

}