title: C# Inherited class BindingList<T> doesn't update controls
body: <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>