Assuming that TEntity is a class, here's an example of what you need to do.
This code goes in the class that is the BindingList<TEntity>.

In this example, BusObj the business object, BusObjList is the business
object list.
I am binding it to a DataGridView with a BindingSource.
This is the code required to get it to sort.

Note: I am implementing IRaiseItemChangedEvents because my BusObj implements
IEditableObject,
and IRaiseItemChangedEvents tells the binding source when they add a a row,
then change their mind and undo it. (In case you were wondering.)

The sort code is from Brian Noyes' excellent book on Data Binding.
It uses a generic comparer; I have included it at the bottom.
His book also includes methods to remove the sort and return to the original
list order,
but I didn't care about that, so I haven't implemented it here.

With a DataGridView, the sorting glyph will show up when it sorts the
column.

public class BusObjList : BindingList<BusObj>, IRaiseItemChangedEvents
{

       //properties and methods of your business object list class

       //these are used to implement the sorting for the BindingList
       private bool m_Sorted = false;
       private ListSortDirection m_SortDirection =
ListSortDirection.Ascending;
       private PropertyDescriptor m_SortProperty = null;

       //Sorting Code
       //To perform the sort of our BindingList<T> class, we have to
provide the overrides
       //of all the sort-related methods and properties from the base
class.

       /// <summary>
       /// Override the value and set it to true so sorting will work on
the list.
       /// </summary>
       protected override bool SupportsSearchingCore
       {
           get
           {
               return true;
           }
       }

       /// <summary>
       /// Override the value and set it to true so sorting will work on
the list.
       /// </summary>
       protected override bool SupportsSortingCore
       {
           get
           {
               return true;
           }
       }

       /// <summary>
       /// Return the value retained locally. Tells if the list is sorted
or not.
       /// </summary>
       protected override bool IsSortedCore
       {
           get
           {
               return m_Sorted;
           }
       }

       /// <summary>
       /// Return the value retained locally. Tells which direction the
list is sorted.
       /// </summary>
       protected override ListSortDirection SortDirectionCore
       {
           get
           {
               return m_SortDirection;
           }
       }

       /// <summary>
       /// Return the value retained locally. Tells which property the list
is sorted on.
       /// </summary>
       protected override PropertyDescriptor SortPropertyCore
       {
           get
           {
               return m_SortProperty;
           }
       }

       /// <summary>
       /// Sets the properties when called by the base class in response to
the ApplySort call.
       /// Delegates to a helper method (ApplySortInternal) to do most of
the work of the sorting.
       /// </summary>
       /// <param name="prop"></param>
       /// <param name="direction"></param>
       protected override void ApplySortCore(PropertyDescriptor prop,
ListSortDirection direction)
       {
           m_SortDirection = direction;
           m_SortProperty = prop;
           BOSortComparer<BusObj> comparer = new
BOSortComparer<BusObj>(prop, direction);
           ApplySortInternal(comparer);
      }

       /// <summary>
       /// Helper class to do the actual sorting work.
       /// </summary>
       /// <param name="comparer"></param>
       private void ApplySortInternal(BOSortComparer<BusObj> comparer)
       {
           //this causes the items in the collection maintained by the base
class to be sorted
           //  according to the criteria provided to the BOSortComparer
class.
           List<BusObj> listRef = this.Items as List<BusObj>;
           if (listRef == null)
               return;

           //let List<T> do the actual sorting based on your comparer
           listRef.Sort(comparer);
           m_Sorted = true;
           //fire an event through a call to the base class OnListChanged
method indicating
           //  that the list has been changed.
           //Use 'reset' because it's likely that most members have been
moved around.
           OnListChanged(new
ListChangedEventArgs(ListChangedType.Reset, -1));
       }

------------------------------------------------------------------------------
This is the generic sort comparer that I am using.

   /// <summary>
   /// Generic SortComparer classes. Used to sort a list of objects by any
property.
   /// </summary>
   /// <typeparam name="T"></typeparam>
   class BOSortComparer<T> : IComparer<T>
   {
       private PropertyDescriptor m_PropDesc = null;
       private ListSortDirection m_Direction = ListSortDirection.Ascending;

       public BOSortComparer(PropertyDescriptor propDesc, ListSortDirection
direction)
       {
           m_PropDesc = propDesc;
           m_Direction = direction;
       }

       int IComparer<T>.Compare(T x, T y)
       {
           object xValue = m_PropDesc.GetValue(x);
           object yValue = m_PropDesc.GetValue(y);
           return CompareValues(xValue, yValue, m_Direction);
       }

       private int CompareValues(object xValue, object yValue,
ListSortDirection direction)
       {
           int retValue = 0;
           if (xValue is IComparable) //can ask the x value
           {
               retValue = ((IComparable)xValue).CompareTo(yValue);
           }
           else if (yValue is IComparable) //can ask the y value
           {
               retValue = ((IComparable)yValue).CompareTo(xValue);
           }
           //not comparable, compare string representations
           else if (!xValue.Equals(yValue))
           {
               retValue = xValue.ToString().CompareTo(yValue.ToString());
           }
           if (direction == ListSortDirection.Ascending)
               return retValue;
           else
               return retValue * -1;

       }

   }

------------------------------------

That should do it for you. Let me know if you have any questions.

RobinS.
GoldMail.com