通过 C# 对 ObservableCollection 进行排序

private ObservableCollection<string> _animals = new ObservableCollection<string>
{
    "Cat", "Dog", "Bear", "Lion", "Mouse",
    "Horse", "Rat", "Elephant", "Kangaroo", "Lizard", 
    "Snake", "Frog", "Fish", "Butterfly", "Human", 
    "Cow", "Bumble Bee"
};

_animals.OrderByDescending(a => a.<what_is_here_?>);

简介

基本上，如果需要显示排序集合，请考虑使用 CollectionViewSource 类：将其 Source 属性分配给源集合(ObservableCollection<T>类的一个实例(。

这个想法是CollectionViewSource类提供CollectionView类的实例。这是对原始(源(集合的一种"投影"，但应用了排序、过滤等。

引用：

• 如何：在 XAML 中使用视图对数据进行排序和分组。
• WPF 的 CollectionViewSource。

活体塑形

WPF 4.5 为CollectionViewSource引入了"实时整形"功能。

引用：

• WPF 4.5 新功能：实时整形。
• CollectionViewSource.IsLiveSort 属性。
• 随着数据值的变化重新定位数据(实时整形(。

溶液

如果仍然需要对ObservableCollection<T>类的实例进行排序，以下是完成操作的方法。ObservableCollection<T>类本身没有排序方法。但是，可以重新创建集合以对项目进行排序：

// Animals property setter must raise "property changed" event to notify binding clients.
// See INotifyPropertyChanged interface for details.
Animals = new ObservableCollection<string>
    {
        "Cat", "Dog", "Bear", "Lion", "Mouse",
        "Horse", "Rat", "Elephant", "Kangaroo",
        "Lizard", "Snake", "Frog", "Fish",
        "Butterfly", "Human", "Cow", "Bumble Bee"
    };
...
Animals = new ObservableCollection<string>(Animals.OrderBy(i => i));

其他详细信息

请注意，OrderBy() 和 OrderByDescending() 方法(与其他 LINQ 扩展方法一样(不会修改源集合！相反，它们创建一个新序列(即实现IEnumerable<T>接口的类的新实例(。因此，有必要重新创建集合。

方式

我要做的方法是从ObservableCollection<>开始构建一个List<>，对其进行排序(通过其Sort()方法，更多关于msdn(，当List<>被排序后，使用Move()方法对ObservableCollection<>重新排序。

代码

public static void Sort<T>(this ObservableCollection<T> collection, Comparison<T> comparison)
{
    var sortableList = new List<T>(collection);
    sortableList.Sort(comparison);
    for (int i = 0; i < sortableList.Count; i++)
    {
        collection.Move(collection.IndexOf(sortableList[i]), i);
    }
}

测试内容

public void TestObservableCollectionSortExtension()
{
    var observableCollection = new ObservableCollection<int>();
    var maxValue = 10;
    // Populate the list in reverse mode [maxValue, maxValue-1, ..., 1, 0]
    for (int i = maxValue; i >= 0; i--)
    {
        observableCollection.Add(i);
    }
    // Assert the collection is in reverse mode
    for (int i = maxValue; i >= 0; i--)
    {
        Assert.AreEqual(i, observableCollection[maxValue - i]);
    }
    // Sort the observable collection
    observableCollection.Sort((a, b) => { return a.CompareTo(b); });
    // Assert elements have been sorted
    for (int i = 0; i < maxValue; i++)
    {
        Assert.AreEqual(i, observableCollection[i]);
    }
}

##Notes这只是一个概念证明，展示了如何在不破坏项目绑定的情况下对ObservableCollection<>进行排序。排序算法有改进和验证的空间(如此处指出的索引检查(。

我看了这些，我正在整理它，然后它打破了绑定，如上所述。 想出了这个解决方案，虽然比你的大多数都简单，但它似乎可以做我想做的,,,

public static ObservableCollection<string> OrderThoseGroups( ObservableCollection<string> orderThoseGroups)
    {
        ObservableCollection<string> temp;
        temp =  new ObservableCollection<string>(orderThoseGroups.OrderBy(p => p));
        orderThoseGroups.Clear();
        foreach (string j in temp) orderThoseGroups.Add(j);
        return orderThoseGroups;

    }

此扩展方法消除了对整个列表进行排序的需要。

相反，它会将每个新项插入到位。因此，列表始终保持排序。

事实证明，此方法仅在集合更改时由于缺少通知而导致许多其他方法失败时才有效。而且速度相当快。

下面的代码应该是防弹的;它已经在大规模生产环境中进行了广泛的测试。

要使用：

// Call on dispatcher.
ObservableCollection<MyClass> collectionView = new ObservableCollection<MyClass>();
var p1 = new MyClass() { Key = "A" }
var p2 = new MyClass() { Key = "Z" }
var p3 = new MyClass() { Key = "D" }
collectionView.InsertInPlace(p1, o => o.Key);
collectionView.InsertInPlace(p2, o => o.Key);
collectionView.InsertInPlace(p3, o => o.Key);
// The list will always remain ordered on the screen, e.g. "A, D, Z" .
// Insertion speed is Log(N) as it uses a binary search.

和扩展方法：

/// <summary>
/// Inserts an item into a list in the correct place, based on the provided key and key comparer. Use like OrderBy(o => o.PropertyWithKey).
/// </summary>
public static void InsertInPlace<TItem, TKey>(this ObservableCollection<TItem> collection, TItem itemToAdd, Func<TItem, TKey> keyGetter)
{
    int index = collection.ToList().BinarySearch(keyGetter(itemToAdd), Comparer<TKey>.Default, keyGetter);
    collection.Insert(index, itemToAdd);
}

和二叉搜索扩展方法：

/// <summary>
/// Binary search.
/// </summary>
/// <returns>Index of item in collection.</returns> 
/// <notes>This version tops out at approximately 25% faster than the equivalent recursive version. This 25% speedup is for list
/// lengths more of than 1000 items, with less performance advantage for smaller lists.</notes>
public static int BinarySearch<TItem, TKey>(this IList<TItem> collection, TKey keyToFind, IComparer<TKey> comparer, Func<TItem, TKey> keyGetter)
{
    if (collection == null)
    {
        throw new ArgumentNullException(nameof(collection));
    }
    int lower = 0;
    int upper = collection.Count - 1;
    while (lower <= upper)
    {
        int middle = lower + (upper - lower) / 2;
        int comparisonResult = comparer.Compare(keyToFind, keyGetter.Invoke(collection[middle]));
        if (comparisonResult == 0)
        {
            return middle;
        }
        else if (comparisonResult < 0)
        {
            upper = middle - 1;
        }
        else
        {
            lower = middle + 1;
        }
    }
    // If we cannot find the item, return the item below it, so the new item will be inserted next.
    return lower;
}

这是一个

ObservableCollection<T>，它会在更改时自动排序，仅在必要时触发排序，并且仅触发单个移动集合更改操作。

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
namespace ConsoleApp4
{
  using static Console;
  public class SortableObservableCollection<T> : ObservableCollection<T>
  {
    public Func<T, object> SortingSelector { get; set; }
    public bool Descending { get; set; }
    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
      base.OnCollectionChanged(e);
      if (SortingSelector == null 
          || e.Action == NotifyCollectionChangedAction.Remove
          || e.Action == NotifyCollectionChangedAction.Reset)
        return;
                      
      var query = this
        .Select((item, index) => (Item: item, Index: index));
      query = Descending
        ? query.OrderByDescending(tuple => SortingSelector(tuple.Item))
        : query.OrderBy(tuple => SortingSelector(tuple.Item));
      var map = query.Select((tuple, index) => (OldIndex:tuple.Index, NewIndex:index))
       .Where(o => o.OldIndex != o.NewIndex);
      using (var enumerator = map.GetEnumerator())
       if (enumerator.MoveNext())
          Move(enumerator.Current.OldIndex, enumerator.Current.NewIndex);

    }
  }
  
  //USAGE
  class Program
  {
    static void Main(string[] args)
    {
      var xx = new SortableObservableCollection<int>() { SortingSelector = i => i };
      xx.CollectionChanged += (sender, e) =>
       WriteLine($"action: {e.Action}, oldIndex:{e.OldStartingIndex},"
         + " newIndex:{e.NewStartingIndex}, newValue: {xx[e.NewStartingIndex]}");
      xx.Add(10);
      xx.Add(8);
      xx.Add(45);
      xx.Add(0);
      xx.Add(100);
      xx.Add(-800);
      xx.Add(4857);
      xx.Add(-1);
      foreach (var item in xx)
        Write($"{item}, ");
    }
  }
}

输出：

action: Add, oldIndex:-1, newIndex:0, newValue: 10
action: Add, oldIndex:-1, newIndex:1, newValue: 8
action: Move, oldIndex:1, newIndex:0, newValue: 8
action: Add, oldIndex:-1, newIndex:2, newValue: 45
action: Add, oldIndex:-1, newIndex:3, newValue: 0
action: Move, oldIndex:3, newIndex:0, newValue: 0
action: Add, oldIndex:-1, newIndex:4, newValue: 100
action: Add, oldIndex:-1, newIndex:5, newValue: -800
action: Move, oldIndex:5, newIndex:0, newValue: -800
action: Add, oldIndex:-1, newIndex:6, newValue: 4857
action: Add, oldIndex:-1, newIndex:7, newValue: -1
action: Move, oldIndex:7, newIndex:1, newValue: -1
-800, -1, 0, 8, 10, 45, 100, 4857,

我创建了一个 ObservableCollection 的扩展方法

public static void MySort<TSource,TKey>(this ObservableCollection<TSource> observableCollection, Func<TSource, TKey> keySelector)
    {
        var a = observableCollection.OrderBy(keySelector).ToList();
        observableCollection.Clear();
        foreach(var b in a)
        {
            observableCollection.Add(b);
        }
    }

它似乎有效，您不需要实现 IComparable

OrderByDescending 的参数是一个返回排序键的函数。在您的情况下，键是字符串本身：

var result = _animals.OrderByDescending(a => a);

例如，如果您想按长度排序，您将编写：

var result = _animals.OrderByDescending(a => a.Length);

myObservableCollection.ToList().Sort((x, y) => x.Property.CompareTo(y.Property));

_animals.OrderByDescending(a => a.<what_is_here_?>);

如果 animals 是对象 Animal 的列表，则可以使用属性对列表进行排序。

public class Animal
{
    public int ID {get; set;}
    public string Name {get; set;}
    ...
}
ObservableCollection<Animal> animals = ...
animals = animals.OrderByDescending(a => a.Name);

/// <summary>
/// Sorts the collection.
/// </summary>
/// <typeparam name="T">The type of the elements of the collection.</typeparam>
/// <param name="collection">The collection to sort.</param>
/// <param name="comparison">The comparison used for sorting.</param>
public static void Sort<T>(this ObservableCollection<T> collection, Comparison<T> comparison = null)
{
    var sortableList = new List<T>(collection);
    if (comparison == null)
        sortableList.Sort();
    else
        sortableList.Sort(comparison);
    for (var i = 0; i < sortableList.Count; i++)
    {
        var oldIndex = collection.IndexOf(sortableList[i]);
        var newIndex = i;
        if (oldIndex != newIndex)
            collection.Move(oldIndex, newIndex);
    }
}

这个解决方案是基于马可的答案。我对他的解决方案有一些问题，因此仅在索引实际更改时才调用Move来改进它。这应该可以提高性能并解决链接的问题。

我也想分享我的想法，因为我遇到了同样的问题。

好吧，只是回答这个问题是：

1 - 向可观察集合类添加扩展，如下所示：

namespace YourNameSpace
{
    public static class ObservableCollectionExtension
    {
        public static void OrderByReference<T>(this ObservableCollection<T> collection, List<T> comparison)
        {
            for (int i = 0; i < comparison.Count; i++)
            {
                if (!comparison.ElementAt(i).Equals(collection.ElementAt(i)))
                    collection.Move(collection.IndexOf(comparison[i]), i);
            }
        }
        
        public static void InsertInPlace<T>(this ObservableCollection<T> collection, List<T> comparison, T item)
        {
            int index = comparison.IndexOf(item);
            comparison.RemoveAt(index);
            collection.OrderByReference(comparison);
            collection.Insert(index, item);
        }
    }
}

2 - 然后像这样使用它：

_animals.OrderByReference(_animals.OrderBy(x => x).ToList());

这会更改您的 ObservableCollection，您可以使用 linq，并且不会更改绑定！

额外：

我已经根据自己的喜好扩展了@Marco和@Contango答案。首先，我想直接使用列表作为比较，所以你会得到这个：

public static void OrderByReference<T>(this ObservableCollection<T> collection, List<T> comparison)
{
    for (int i = 0; i < comparison.Count; i++)
    {
        collection.Move(collection.IndexOf(comparison[i]), i);
    }
}

并像这样使用：

YourObservableCollection.OrderByReference(YourObservableCollection.DoYourLinqOrdering().ToList());

然后我想，既然这总是移动所有内容并触发 ObservableCollection 中的移动，为什么不比较对象是否已经在那里，这带来了我在开始时使用 Equals 比较器放置的内容。

将对象添加到正确的位置听起来也不错，但我想要一种简单的方法来做到这一点。所以我想出了这个：

public static void InsertInPlace<T>(this ObservableCollection<T> collection, List<T> comparison, T item)
{
    collection.Insert(comparison.IndexOf(item), item);
}

你发送一个列表，其中包含你想要的新对象和这个新对象，

所以你需要创建一个列表，然后添加这个新对象，如下所示：

var YourList = YourObservableCollection.ToList();
var YourObject = new YourClass { ..... };
YourList.Add(YourObject);
YourObservableCollection.InsertInPlace(YourList.DoYourLinqOrdering().ToList(), YourObject);

但是由于 ObservableCollection 的顺序可能与列表不同，因为 "DoYourLinqOrdering((" 中的选择(如果集合以前没有排序，就会发生这种情况(，我在插入中添加了第一个扩展 (OrderByReference(，正如您在答案开头看到的那样。如果不需要移动 itens araround，它不会花很长时间，所以我没有看到使用它的问题。

随着性能的发展，我通过检查每个方法完成所需的时间来比较这些方法，所以不理想，但无论如何，我已经测试了一个具有 20000 个 iten 的可观察集合。对于 OrderByReference，我没有看到通过添加 Equal 对象检查器在性能上有很大的差异，但如果不是所有 itens 都需要移动它，它会更快，并且不会在 colleciton 上触发不必要的 Move 事件更改，所以这就是一些东西。对于 InsertInPlace 是一回事，如果 ObservableCollection 已经排序，那么仅仅检查对象是否在正确的位置比移动所有 itens 更快，因此如果它只是通过 Equals 语句，并且您可以确保一切都在应有的位置，则时间差异不会很大。

请注意，如果您将此扩展用于不机械的对象或包含更多或更少对象的列表，您将获得 ArgumentOutOfRangeException 或其他一些意外行为。

希望这对某人有所帮助！

我对某个类字段(距离(进行了排序。

public class RateInfo 
{
    public string begin { get; set; }
    public string end { get; set; }
    public string price { get; set; }
    public string comment { get; set; }
    public string phone { get; set; }
    public string ImagePath { get; set; }
    public string what { get; set; }
    public string distance { get; set; }
}    
public ObservableCollection<RateInfo> Phones { get; set; }
public List<RateInfo> LRate { get; set; }
public ObservableCollection<RateInfo> Phones { get; set; }
public List<RateInfo> LRate { get; set; }
......
foreach (var item in ph)
        {
            LRate.Add(new RateInfo { begin = item["begin"].ToString(), end = item["end"].ToString(), price = item["price"].ToString(), distance=kilom, ImagePath = "chel.png" });
        }
       LRate.Sort((x, y) => x.distance.CompareTo(y.distance));
        foreach (var item in LRate)
        {
            Phones.Add(item);
        }

这是 Shimmy 的一个略有变化，用于已经实现众所周知的 IComparable<T> 接口的类集合。在这种情况下，"排序依据"选择器是隐式的。

public class SortedObservableCollection<T> : ObservableCollection<T> where T : IComparable<T>
{
    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        base.OnCollectionChanged(e);
        if (e.Action != NotifyCollectionChangedAction.Reset &&
            e.Action != NotifyCollectionChangedAction.Move &&
            e.Action != NotifyCollectionChangedAction.Remove)
        {
            var query = this.Select((item, index) => (Item: item, Index: index)).OrderBy(tuple => tuple.Item, Comparer.Default);
            var map = query.Select((tuple, index) => (OldIndex: tuple.Index, NewIndex: index)).Where(o => o.OldIndex != o.NewIndex);
            using (var enumerator = map.GetEnumerator())
            {
                if (enumerator.MoveNext())
                {
                    base.MoveItem(enumerator.Current.OldIndex, enumerator.Current.NewIndex);
                }
            }
        }
    }
    // (optional) user is not allowed to move items in a sorted collection
    protected override void MoveItem(int oldIndex, int newIndex) => throw new InvalidOperationException();
    protected override void SetItem(int index, T item) => throw new InvalidOperationException();
    private class Comparer : IComparer<T>
    {
        public static readonly Comparer Default = new Comparer();
        public int Compare(T x, T y) => x.CompareTo(y);
    }
    // explicit sort; sometimes needed.
    public virtual void Sort()
    {
        if (Items.Count <= 1)
            return;
        var items = Items.ToList();
        Items.Clear();
        items.Sort();
        foreach (var item in items)
        {
            Items.Add(item);
        }
        OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }
}

如果性能是您的主要关注点，并且您不介意收听不同的事件，那么这是获得稳定排序的方法：

public static void Sort<T>(this ObservableCollection<T> list) where T : IComparable<T>
{
    int i = 0;
    foreach (var item in list.OrderBy(x => x))
    {
        if (!item.Equals(list[i]))
        {
            list[i] = item;
        }
        i++;
    }
}

就稳定排序而言，我不确定是否有更简单、更快(至少在理论上(的东西。在有序列表上执行 ToArray 可能会使枚举更快，但空间复杂性会降低。您也可以取消Equals检查以加快速度，但我想减少更改通知是一件受欢迎的事情。

此外，这不会破坏任何绑定。

请注意，这引发了一堆Replace事件而不是 Move(对于排序操作来说更值得期待(，而且与此线程中的其他 Move 方法相比，引发的事件数量很可能更多，但我认为它不太可能对性能产生影响。大多数 UI 元素必须已实现IList并且对ILists执行替换应该比 Move 更快。但更改的事件越多，屏幕刷新次数就越多。您必须对其进行测试才能看到其含义。

<小时 />

有关Move答案，请参阅此处。没有看到更正确的实现，即使您在集合中有重复项也能正常工作。

    public static ObservableCollection<T> Sort<T>(this ObservableCollection<T> collection, Comparison<T> comparison)
    {
        var sortableList = new List<T>(collection);
        sortableList.Sort(comparison);
        collection.Clear();
        sortableList.ForEach(item => { collection.Add(item); });
        return collection;
    }