tech.windowsapplication1.com //about .Net and life on the other side

It is good to see that the code posted in here by you requires minimum knowledge of the System.ComponentModel and System.Reflection namespace. I am sure it will be of help to me in case I encounter a similar problem. Will keep this page bookmarked.
electronic deer repellent

This worked well for me, except this line:
List items = this.Items as List;

In VS 2010/.Net 4.0, the above "items" was always null, and so nothing could get sorted. So I added implementations of InsertionSort and QuickSort algorithms (I found QuickSort to be much quicker).

Hopefully this will benefit other Googlers that come across this code. You should be able to copy and past this code into a single codefile, though you will need to add a namespace declaration.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Collections;
using System.Reflection;

public class SortableBindingList : BindingList
{
private bool _isSorted;
private ListSortDirection _sortDirection;
private PropertyDescriptor _sortProperty;

//This override shows the binded object, that our list supports sorting
protected override bool SupportsSortingCore
{
get { return true; }
}

//And that it can sort bi-directional
protected override ListSortDirection SortDirectionCore
{
get { return _sortDirection; }
}

//And that it can sort by T typed object's properties
protected override PropertyDescriptor SortPropertyCore
{

get { return _sortProperty; }
}

//This is the method, what gets called when the sort event occurs in the bound object
protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
{
if (this.Items != null)
{
//this.InsertionSortItems(prop, direction); //Takes longer
this.QuickSortItems(prop, direction);
_isSorted = true;
_sortDirection = direction;
_sortProperty = prop;
}
else
{
_isSorted = false;
}
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
///
/// Sort this.Items using QuickSort algorithm.
///
///
///
protected void QuickSortItems(PropertyDescriptor prop, ListSortDirection direction)
{
this.QuickSort(this.Items, 0, this.Items.Count - 1, new PropertyComparer(prop.Name, direction));
}
///
/// To be called recursively, and from QuickSortItems() method.
///
///
///
///
///
protected void QuickSort(IList items, int leftBoundary, int rightBoundary, PropertyComparer comparer)
{

var leftWorkingIndex = leftBoundary;
var rightWorkingIndex = rightBoundary;
double pivotIndex = ((leftBoundary + rightBoundary) / 2);
var pivotItem = items[Convert.ToInt32(pivotIndex)];
T leftItem;
T rightItem;
T tempItem;
while (leftWorkingIndex <= rightWorkingIndex)
{
leftItem = items[leftWorkingIndex];
while (comparer.Compare(leftItem,pivotItem) < 0)
{
leftWorkingIndex++;
leftItem = items[leftWorkingIndex];
}
rightItem = items[rightWorkingIndex];
while (comparer.Compare(rightItem,pivotItem) > 0)
{
rightWorkingIndex--;
rightItem = items[rightWorkingIndex];
}
if (leftWorkingIndex <= rightWorkingIndex)
{
tempItem = items[leftWorkingIndex];
items[leftWorkingIndex] = items[rightWorkingIndex];
leftWorkingIndex++;
items[rightWorkingIndex] = tempItem;
rightWorkingIndex--;
}
}
if (leftBoundary < rightWorkingIndex)
{
QuickSort(items, leftBoundary, rightWorkingIndex,comparer);
}
if (leftWorkingIndex < rightBoundary)
{
QuickSort(items, leftWorkingIndex, rightBoundary,comparer);
}
}
///
/// Sort this.Items using InsertionSort algorithm
///
///
///
protected void InsertionSortItems(PropertyDescriptor prop, ListSortDirection direction)
{
var comparer = new PropertyComparer(prop.Name, direction);
int j;
T item;
for (int i = 1; i < this.Items.Count; i++)
{
item = this.Items[i];
j = i;
while ((j > 0) && (comparer.Compare(this.Items[j - 1], item) > 0))
{
this.Items[j] = this.Items[j - 1];
j = j - 1;
}
this.Items[j] = item;
}

}

//This shows if our list is already sorted or not
protected override bool IsSortedCore
{
get { return _isSorted; }
}

//Removing the sort
protected override void RemoveSortCore()
{
_isSorted = false;
}

public SortableBindingList(IList list)
: base(list)
{
}
}

public class PropertyComparer : IComparer
{
private PropertyInfo _property;
private ListSortDirection _sortDirection;

public PropertyComparer(string sortProperty, ListSortDirection sortDirection)
{
_property = typeof(T).GetProperty(sortProperty);
this._sortDirection = sortDirection;
}
///
/// If return value less than 0, X is less than Y.
/// If return value equals 0, X equals Y.
/// If return value greater than 0, X greater than Y.
///
/// First object to be compared.
/// Second object to be compared.
///
public int Compare(T x, T y)
{
object valueX = _property.GetValue(x, null);
object valueY = _property.GetValue(y, null);

if (_sortDirection == ListSortDirection.Ascending)
return Comparer.Default.Compare(valueX, valueY);

return Comparer.Default.Compare(valueY, valueX);
}
}