/// <summary> /// This is overridden to apply a sort based on the selected property descriptor and sort direction /// </summary> /// <param name="prop">The property descriptor to use for the sort values</param> /// <param name="direction">The direction of the sort</param> protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction) { PropertyComparer <T> comparer = new PropertyComparer <T>(prop, direction); ((List <T>)base.Items).Sort(comparer); sortProperty = prop; sortDirection = direction; isSorted = true; this.OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1)); }
//===================================================================== /// <summary> /// This compares the two items using the values obtained from the property descriptors and returns a /// value indicating whether one is less than, equal to, or greater than the other. /// </summary> /// <param name="x">The first object to compare</param> /// <param name="y">The second object to compare</param> /// <returns>Returns less than zero when object X is less than object Y, zero if they are equal, greater /// than zero when object X is greater than object Y.</returns> public int Compare(T x, T y) { object value1, value2; int result; // Get the value from the property in each object value1 = PropertyComparer <T> .GetPropertyValue(x, property.Name); value2 = PropertyComparer <T> .GetPropertyValue(y, property.Name); // Handle null values first if (value1 == null && value2 == null) { return(0); } if (value1 == null && value2 != null) { return((direction == ListSortDirection.Ascending) ? -1 : 1); } if (value1 != null && value2 == null) { return((direction == ListSortDirection.Ascending) ? 1 : -1); } // Try comparing using IComparable. If that won't work, see if they are equal. If not, compare them // as strings. IComparable comp = value1 as IComparable; if (comp != null) { result = comp.CompareTo(value2); } else if (value1.Equals(value2)) { result = 0; } else { result = String.Compare(value1.ToString(), value2.ToString(), StringComparison.Ordinal); } // Invert the result for descending order if (direction == ListSortDirection.Descending) { result *= -1; } return(result); }
/// <summary> /// This searches for the index of the item that has the specified property descriptor with the specified /// value. /// </summary> /// <param name="prop">The property descriptor used for the search</param> /// <param name="key">The value of the property to match</param> /// <returns>Returns the zero-based index of the item that matches the property descriptor and contains /// the specified value.</returns> protected override int FindCore(PropertyDescriptor prop, object key) { return(((List <T>)base.Items).FindIndex(0, base.Count, (x) => { int result; object value = PropertyComparer <T> .GetPropertyValue(x, prop.Name); // Handle null values first if (key == null && value == null) { return true; } if ((key == null && value != null) || (key != null && value == null)) { return false; } // Try comparing using IComparable. If that won't work, see if they are equal. If not, // compare them as strings. if (key is IComparable) { result = ((IComparable)key).CompareTo(value); } else if (key.Equals(value)) { result = 0; } else { result = String.Compare(key.ToString(), value.ToString(), StringComparison.Ordinal); } return (result == 0); })); }