C# Inherited class BindingList<T> doesn't update controls
<p>I have a class which inherits from BindingList to apply sorting to a bindinglist. The sorting works fine, but when I add or remove an item from the list the bounded control isn't updated. I think i miss something in the class, but I don't know what. </p>

<p>I've found the code of the class somewhere online, but I don't know where I found it. My question is, why does this class doesn'u update my control when I update or remove items from the list?</p>

<p>Here is the complete class</p>

<pre><code>public class SortableBindingList&lt;T&gt; : BindingList&lt;T&gt;
{
    #region Membar variables
    private bool _isSortedValue;
    private ArrayList _sortedList;
    private ArrayList _unsortedItems;
    private PropertyDescriptor _sortPropertyValue;
    private ListSortDirection _sortDirectionValue;
    #endregion

    #region Constructor
    public SortableBindingList()
    {
    }

    public SortableBindingList(IList&lt;T&gt; list):base(list)
    {
    }
    #endregion

    #region Overrided Properties
    protected override bool SupportsSearchingCore
    {
        get { return true; }
    }
    protected override bool SupportsSortingCore
    {
        get { return true; }
    }
    protected override bool IsSortedCore
    {
        get { return _isSortedValue; }
    }

    protected override PropertyDescriptor SortPropertyCore
    {
        get { return _sortPropertyValue; }
    }

    protected override ListSortDirection SortDirectionCore
    {
        get { return _sortDirectionValue; }
    }
    #endregion

    #region Public methods
    public int Find(string property, object key)
    {
        // Check the properties for a property with the specified name.
        PropertyDescriptorCollection properties =
            TypeDescriptor.GetProperties(typeof(T));
        PropertyDescriptor prop = properties.Find(property, true);

        // If there is not a match, return -1 otherwise pass search to
        // FindCore method.
        if (prop == null)
            return -1;
        else
            return FindCore(prop, key);
    }

    public void RemoveSort()
    {
        RemoveSortCore();
    }

    public void Sort(string property, ListSortDirection direction)
    {
        // Get all the properties of the object T
        PropertyDescriptorCollection properties = 
            TypeDescriptor.GetProperties(typeof(T));

        // Find the specified property in de collection and ignore case
        PropertyDescriptor prop = properties.Find(property, true);

        if (prop != null)
            ApplySortCore(prop, direction);
    }
    #endregion

    #region Overrided methods
    // The FindCore method searches a list and returns the index of a found item
    protected override int FindCore(PropertyDescriptor prop, object key)
    {
        // Get the property info for the specified property.
        PropertyInfo propInfo = typeof(T).GetProperty(prop.Name);
        T item;

        if (key != null)
        {
            // Loop through the items to see if the key
            // value matches the property value.
            for (int i = 0; i &lt; Count; ++i)
            {
                item = (T)Items[i];
                if (propInfo.GetValue(item, null).Equals(key))
                    return i;
            }
        }
        return -1;

    }

    protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
    {
        _sortedList = new ArrayList();

        // Check to see if the property type we are sorting by implements
        // the IComparable interface.
        Type interfaceType = prop.PropertyType.GetInterface("IComparable");

        if (interfaceType != null)
        {
            // If so, set the SortPropertyValue and SortDirectionValue.
            _sortPropertyValue = prop;
            _sortDirectionValue = direction;

            _unsortedItems = new ArrayList(this.Count);

            // Loop through each item, adding it the the sortedItems ArrayList.
            foreach (Object item in this.Items)
            {
                _sortedList.Add(prop.GetValue(item));
                _unsortedItems.Add(item);
            }
            // Call Sort on the ArrayList.
            _sortedList.Sort();
            T temp;

            // Check the sort direction and then copy the sorted items
            // back into the list.
            if (direction == ListSortDirection.Descending)
                _sortedList.Reverse();

            for (int i = 0; i &lt; this.Count; i++)
            {
                int position = Find(prop.Name, _sortedList[i]);
                if (position != i)
                {
                    temp = this[i];
                    this[i] = this[position];
                    this[position] = temp;
                }
            }

            _isSortedValue = true;

            // Raise the ListChanged event so bound controls refresh their
            // values.
            OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
        }
        else
            // If the property type does not implement IComparable, let the user
            // know.
            throw new NotSupportedException("Cannot sort by " + prop.Name +
                ". This" + prop.PropertyType.ToString() +
                " does not implement IComparable");

    }

    protected override void RemoveSortCore()
    {
        int position;
        object temp;

        // Ensure the list has been sorted.
        if (_unsortedItems != null)
        {
            // Loop through the unsorted items and reorder the
            // list per the unsorted list.
            for (int i = 0; i &lt; _unsortedItems.Count; )
            {
                position = this.Find(_sortPropertyValue.Name,
                    _unsortedItems[i].GetType().GetProperty(_sortPropertyValue.Name).GetValue(_unsortedItems[i], null));

                if (position &gt; 0 &amp;&amp; position != i)
                {
                    temp = this[i];
                    this[i] = this[position];
                    this[position] = (T)temp;
                    i++;
                }
                else if (position == i)
                    i++;
                else
                    // If an item in the unsorted list no longer exists,
                    // delete it.
                    _unsortedItems.RemoveAt(i);
            }

            _isSortedValue = false;

            OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
        }

    }
    #endregion
}
</code></pre>
