Making Your Generic Lists Sortable

namespace ExampleIncorporated.BigProduct
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
 
    /// <summary>
    /// Provides a generic method of storing objects in a bindable and sortable collection.
    /// </summary>
    /// <typeparam name="T">The type of object stored in the collection.</typeparam>
    public class SortableBindingList<T> : BindingList<T>
    {
        // reference to the list provided at the time of instantiation
        List<T> originalList;
        ListSortDirection sortDirection;
        PropertyDescriptor sortProperty;
 
        /// <summary>
        /// Used to store a local cache of generated methods used to sort the collection.
        /// </summary>
        /// <remarks>
        /// This in place so that the method used to sort a property will not need to be generated multiple times.
        /// </remarks>
        Action<SortableBindingList<T>, List<T>>
                       populateBaseList = (a, b) => a.ResetItems(b);
 
        // a cache of functions that perform the sorting
        // for a given type, property, and sort direction
        static Dictionary<string, Func<List<T>, IEnumerable<T>>>
           cachedOrderByExpressions = new Dictionary<string, Func<List<T>,
                                                     IEnumerable<T>>>();
 
        /// <summary>
        /// Initializes a new instance of the <see cref="SortableBindingList&lt;T&gt;"/> class.
        /// </summary>
        public SortableBindingList()
        {
            originalList = new List<T>();
        }
 
        /// <summary>
        /// Initializes a new instance of the <see cref="SortableBindingList&lt;T&gt;"/> class.
        /// </summary>
        /// <param name="enumerable">The enumerable.</param>
        public SortableBindingList(IEnumerable<T> enumerable)
        {
            originalList = enumerable.ToList();
            populateBaseList(this, originalList);
        }
 
        /// <summary>
        /// Initializes a new instance of the <see cref="SortableBindingList&lt;T&gt;"/> class.
        /// </summary>
        /// <param name="list">The list.</param>
        public SortableBindingList(List<T> list)
        {
            originalList = list;
            populateBaseList(this, originalList);
        }
 
        /// <summary>
        /// Gets a value indicating whether the list is sorted.
        /// </summary>
        /// <value></value>
        /// <returns>true if the list is sorted; otherwise, false. The default is false.</returns>
        protected override bool IsSortedCore
        {
            get
            {
                return sortProperty != null;
            }
        }
 
        /// <summary>
        /// Sorts the items if overridden in a derived class; otherwise, throws a <see cref="T:System.NotSupportedException"/>.
        /// </summary>
        /// <param name="prop">A <see cref="T:System.ComponentModel.PropertyDescriptor"/> that specifies the property to sort on.</param>
        /// <param name="direction">One of the <see cref="T:System.ComponentModel.ListSortDirection"/>  values.</param>
        /// <exception cref="T:System.NotSupportedException">Method is not overridden in a derived class. </exception>
        protected override void ApplySortCore(PropertyDescriptor prop,
                                ListSortDirection direction)
        {
            // Update our local variables with the values given to us by the sorting control
            sortDirection = direction;
            sortProperty = prop;
 
            // Get the name of our method based on the sort direction
            string orderByMethodName = sortDirection ==
                ListSortDirection.Ascending ? "OrderBy" : "OrderByDescending";
 
            // Get the key used to cache the method based on the type GUID and method name
            string cacheKey = string.Concat(
                typeof(T).GUID,
                prop.Name,
                orderByMethodName);
 
            // If the method is not in our cache, generate the sort method
            if (!cachedOrderByExpressions.ContainsKey(cacheKey))
                CreateOrderByMethod(prop, orderByMethodName, cacheKey);
 
            // Execute the sort method on the base list
            ResetItems(cachedOrderByExpressions[cacheKey](originalList).ToList());
 
            // Re-bind the collection
            ResetBindings();
        }
 
 
        /// <summary>
        /// Creates the order by method.
        /// </summary>
        /// <param name="prop">The property to sort by.</param>
        /// <param name="orderByMethodName">Name of the order by method.</param>
        /// <param name="cacheKey">The cache key.</param>
        private void CreateOrderByMethod(PropertyDescriptor prop,
                     string orderByMethodName, string cacheKey)
        {
 
            ParameterExpression sourceParameter = Expression.Parameter(typeof(List<T>), "source");
            ParameterExpression lambdaParameter = Expression.Parameter(typeof(T), "lambdaParameter");
 
            // Get the type of the sort property
            PropertyInfo accesedMember = typeof(T).GetProperty(prop.Name);
 
            // Create an expression that selects the value of our sort property
            LambdaExpression propertySelectorLambda =
                Expression.Lambda(Expression.MakeMemberAccess(lambdaParameter,
                                  accesedMember), lambdaParameter);
 
            // Create our method
            MethodInfo orderByMethod = typeof(Enumerable).GetMethods()
                                          .Where(a => a.Name == orderByMethodName &&
                                                       a.GetParameters().Length == 2)
                                          .Single()
                                          .MakeGenericMethod(typeof(T), prop.PropertyType);
 
            // Create the linq order-by method
            var orderByExpression = Expression.Lambda<Func<List<T>, IEnumerable<T>>>(
                                        Expression.Call(orderByMethod,
                                                new Expression[] { sourceParameter,
                                                               propertySelectorLambda }),
                                                sourceParameter);
 
            // Add the compiled method to the cache
            cachedOrderByExpressions.Add(cacheKey, orderByExpression.Compile());
        }
 
        /// <summary>
        /// Removes any sort applied with <see cref="M:System.ComponentModel.BindingList`1.ApplySortCore(System.ComponentModel.PropertyDescriptor,System.ComponentModel.ListSortDirection)"/> if sorting is implemented in a derived class; otherwise, raises <see cref="T:System.NotSupportedException"/>.
        /// </summary>
        /// <exception cref="T:System.NotSupportedException">Method is not overridden in a derived class. </exception>
        protected override void RemoveSortCore()
        {
            ResetItems(originalList);
        }
 
        private void ResetItems(List<T> items)
        {
 
            base.ClearItems();
 
            for (int i = 0; i < items.Count; i++)
            {
                base.InsertItem(i, items[i]);
            }
        }
 
        /// <summary>
        /// Gets a value indicating whether the list supports sorting.
        /// </summary>
        /// <value></value>
        /// <returns>true if the list supports sorting; otherwise, false. The default is false.</returns>
        protected override bool SupportsSortingCore
        {
            get
            {
                // indeed we do
                return true;
            }
        }
 
        /// <summary>
        /// Gets the direction the list is sorted.
        /// </summary>
        /// <value></value>
        /// <returns>One of the <see cref="T:System.ComponentModel.ListSortDirection"/> values. The default is <see cref="F:System.ComponentModel.ListSortDirection.Ascending"/>. </returns>
        protected override ListSortDirection SortDirectionCore
        {
            get
            {
                return sortDirection;
            }
        }
 
        /// <summary>
        /// Gets the property descriptor that is used for sorting the list if sorting is implemented in a derived class; otherwise, returns null.
        /// </summary>
        /// <value></value>
        /// <returns>The <see cref="T:System.ComponentModel.PropertyDescriptor"/> used for sorting the list.</returns>
        protected override PropertyDescriptor SortPropertyCore
        {
            get
            {
                return sortProperty;
            }
        }
 
        /// <summary>
        /// Raises the <see cref="E:System.ComponentModel.BindingList`1.ListChanged"/> event.
        /// </summary>
        /// <param name="e">A <see cref="T:System.ComponentModel.ListChangedEventArgs"/> that contains the event data.</param>
        protected override void OnListChanged(ListChangedEventArgs e)
        {
            originalList = base.Items.ToList();
        }
    }
}

List<myObject> MyList = DataLayer.GetMyList();
 
myDataGridView.DataSource = new SortableBindingList<myObject>(MyList);