如何排序ObservableCollection

Question

我有一个ObservableCollection和一个WPF UserControl是Databound它。 Control是一个图表，显示ObservableCollection中每个BarData类型项目的垂直条。

ObservableCollection<BarData> 

class BarData 
{ 
    public DateTime StartDate {get; set;} 
    public double MoneySpent {get; set;} 
    public double TotalMoneySpentTillThisBar {get; set;} 
} 

现在我想整理出基于起始日期的的ObservableCollection，以便BarData的将在集合中增加起始日期的顺序。 然后，我可以在这样每个BarData计算TotalMoneySpentTillThisBar的价值观 -

var collection = new ObservableCollection<BarData>(); 
//add few BarData objects to collection 
collection.Sort(bar => bar.StartData); // this is ideally the kind of function I was looking for which does not exist 
double total = 0.0; 
collection.ToList().ForEach(bar => { 
            bar.TotalMoneySpentTillThisBar = total + bar.MoneySpent; 
            total = bar.TotalMoneySpentTillThisBar; 
            } 
          ); 

我知道我可以使用ICollectionView进行排序，对veiwing过滤数据，但不会改变实际的集合。我需要对实际集合进行排序，以便为每个项目计算TotalMoneySpentTillThisBar。它的价值取决于收集项目的顺序。

谢谢。

Answer 1

对ObservableCollection进行排序的问题在于，每次更改集合时，都会触发事件。所以对于一种从一个位置移除物品并将它们添加到另一个位置的行为，最终会发生大量事件。

我认为你最好打赌就是只要按正确的顺序插入ObservableCollection开始。从集合中删除项目不会影响订购。我刮起了快速的扩展方法来说明

public static void InsertSorted<T>(this ObservableCollection<T> collection, T item, Comparison<T> comparison) 
    { 
     if (collection.Count == 0) 
      collection.Add(item); 
     else 
     { 
      bool last = true; 
      for (int i = 0; i < collection.Count; i++) 
      { 
       int result = comparison.Invoke(collection[i], item); 
       if (result >= 1) 
       { 
        collection.Insert(i, item); 
        last = false; 
        break; 
       } 
      } 
      if (last) 
       collection.Add(item); 
     } 
    } 

所以，如果你使用的字符串（例如），代码看起来像这样

 ObservableCollection<string> strs = new ObservableCollection<string>(); 
     Comparison<string> comparison = new Comparison<string>((s1, s2) => { return String.Compare(s1, s2); }); 
     strs.InsertSorted("Mark", comparison); 
     strs.InsertSorted("Tim", comparison); 
     strs.InsertSorted("Joe", comparison); 
     strs.InsertSorted("Al", comparison); 

编辑

你可以如果扩展ObservableCollection并提供您自己的插入/添加方法，请保持呼叫相同。类似这样的：

public class BarDataCollection : ObservableCollection<BarData> 
{ 
    private Comparison<BarData> _comparison = new Comparison<BarData>((bd1, bd2) => { return DateTime.Compare(bd1.StartDate, bd2.StartDate); }); 

    public new void Insert(int index, BarData item) 
    { 
     InternalInsert(item); 
    } 

    protected override void InsertItem(int index, BarData item) 
    { 
     InternalInsert(item); 
    } 

    public new void Add(BarData item) 
    { 
     InternalInsert(item); 
    } 

    private void InternalInsert(BarData item) 
    { 
     if (Items.Count == 0) 
      Items.Add(item); 
     else 
     { 
      bool last = true; 
      for (int i = 0; i < Items.Count; i++) 
      { 
       int result = _comparison.Invoke(Items[i], item); 
       if (result >= 1) 
       { 
        Items.Insert(i, item); 
        last = false; 
        break; 
       } 
      } 
      if (last) 
       Items.Add(item); 
     } 
    } 
} 

插入索引被忽略。

 BarData db1 = new BarData(DateTime.Now.AddDays(-1)); 
     BarData db2 = new BarData(DateTime.Now.AddDays(-2)); 
     BarData db3 = new BarData(DateTime.Now.AddDays(1)); 
     BarData db4 = new BarData(DateTime.Now); 
     BarDataCollection bdc = new BarDataCollection(); 
     bdc.Add(db1); 
     bdc.Insert(100, db2); 
     bdc.Insert(1, db3); 
     bdc.Add(db4); 

Answer 2

我刚刚创建一个扩展ObservableCollection，因为随着时间的推移，我也想，我已经习惯了从List（Contains，IndexOf，AddRange，RemoveRange等）使用其他功能

类

我通常使用的东西像

MyCollection.Sort(p => p.Name);

这里是我的排序implementa重刑

/// <summary> 
/// Expanded ObservableCollection to include some List<T> Methods 
/// </summary> 
[Serializable] 
public class ObservableCollectionEx<T> : ObservableCollection<T> 
{ 

    /// <summary> 
    /// Constructors 
    /// </summary> 
    public ObservableCollectionEx() : base() { } 
    public ObservableCollectionEx(List<T> l) : base(l) { } 
    public ObservableCollectionEx(IEnumerable<T> l) : base(l) { } 

    #region Sorting 

    /// <summary> 
    /// Sorts the items of the collection in ascending order according to a key. 
    /// </summary> 
    /// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam> 
    /// <param name="keySelector">A function to extract a key from an item.</param> 
    public void Sort<TKey>(Func<T, TKey> keySelector) 
    { 
     InternalSort(Items.OrderBy(keySelector)); 
    } 

    /// <summary> 
    /// Sorts the items of the collection in descending order according to a key. 
    /// </summary> 
    /// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam> 
    /// <param name="keySelector">A function to extract a key from an item.</param> 
    public void SortDescending<TKey>(Func<T, TKey> keySelector) 
    { 
     InternalSort(Items.OrderByDescending(keySelector)); 
    } 

    /// <summary> 
    /// Sorts the items of the collection in ascending order according to a key. 
    /// </summary> 
    /// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam> 
    /// <param name="keySelector">A function to extract a key from an item.</param> 
    /// <param name="comparer">An <see cref="IComparer{T}"/> to compare keys.</param> 
    public void Sort<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer) 
    { 
     InternalSort(Items.OrderBy(keySelector, comparer)); 
    } 

    /// <summary> 
    /// Moves the items of the collection so that their orders are the same as those of the items provided. 
    /// </summary> 
    /// <param name="sortedItems">An <see cref="IEnumerable{T}"/> to provide item orders.</param> 
    private void InternalSort(IEnumerable<T> sortedItems) 
    { 
     var sortedItemsList = sortedItems.ToList(); 

     foreach (var item in sortedItemsList) 
     { 
      Move(IndexOf(item), sortedItemsList.IndexOf(item)); 
     } 
    } 

    #endregion // Sorting 
} 

Answer 3

hummm第一个问题，我对你是： 有什么重要的是你的ObservableCollection进行排序，或者是你真正想要的是有分类的图形用户界面中显示？

我假定目标是有一个排序显示，将“实时”更新。然后我看到2个解决方案

1. 让你ObservableCollection的ICollectionView，并对其进行排序，这里 http://marlongrech.wordpress.com/2008/11/22/icollectionview-explained/

2. 解释绑定您的ObservableCollection到CollectionViewsource，就可以添加排序，然后使用该CollectionViewSource作为ListView的ItemSource。

即：

添加这个命名空间

xmlns:scm="clr-namespace:System.ComponentModel;assembly=WindowsBase" 

然后

<CollectionViewSource x:Key='src' Source="{Binding MyObservableCollection, ElementName=MainWindowName}"> 
    <CollectionViewSource.SortDescriptions> 
     <scm:SortDescription PropertyName="MyField" /> 
    </CollectionViewSource.SortDescriptions> 

</CollectionViewSource> 

并绑定这样

<ListView ItemsSource="{Binding Source={StaticResource src}}" > 

Answer 4

那么排序在不同的集合使用LINQ的数据：这为我工作

var collection = new List<BarData>(); 
//add few BarData objects to collection 

// sort the data using LINQ 
var sorted = from item in collection orderby item.StartData select item; 

// create observable collection 
var oc = new ObservableCollection<BarData>(sorted); 

。

Answer 5

同样使用LINQ/Extension方法，可以通过不设置源col到已排序的源来排除NotifyPropertyChanged事件，但清除原始并添加已排序项的项目。 （如果实施，这将继续触发Collectionchanged事件）。

<Extension> 
Public Sub SortByProp(Of T)(ByRef c As ICollection(Of T), PropertyName As String) 
    Dim l = c.ToList 
    Dim sorted = l.OrderBy(Function(x) x.GetType.GetProperty(PropertyName).GetValue(x)) 

    c.Clear() 
    For Each i In sorted 
     c.Add(i) 
    Next 

End Sub