我有以下的 ObservableCollection<string>。我需要对它进行字母顺序排序。
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，但我不知道如何正确使用它。
_animals.OrderByDescending(a => a.<what_is_here_?>);
我该如何做到这一点？
基本上，如果需要显示已排序的集合，请考虑使用 CollectionViewSource 类：将其 Source 属性分配（“绑定”）到源集合 - ObservableCollection<T> 类的一个实例。
这样做的想法是 CollectionViewSource 类提供了 CollectionView 类的实例。
这是原始（源）集合的一种“投影”，但应用了排序、过滤等操作。
参考资料：
WPF 4.5 引入了 CollectionViewSource 的“实时排序”功能。
参考资料：
如果仍然需要对 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]);
}
}
##注意事项
本文仅为概念验证，演示如何对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
myObservableCollection.ToList().Sort((x, y) => x.Property.CompareTo(y.Property));
OrderByDescending的参数是一个返回用于排序的键的函数。在您的情况下，该键是字符串本身。var result = _animals.OrderByDescending(a => a);
var result = _animals.OrderByDescending(a => a.Length);
OrderByDescending()方法后，集合中项目的顺序不会改变。 - Sergey Vyacheslavovich Brunov_animals.OrderByDescending(a => a.<what_is_here_?>);
public class Animal
{
public int ID {get; set;}
public string Name {get; set;}
...
}
ObservableCollection<Animal> animals = ...
animals = animals.OrderByDescending(a => a.Name);
OrderByDescending()方法后，集合中的项目顺序不会被修改。 - Sergey Vyacheslavovich BrunovObservableCollection，我尝试了这个方法，但它停止识别我的集合-它停止允许我向集合中添加东西并在GUI中反映出更改。绑定断开了。更好的方法可能是将排序后的集合分配给另一个集合，然后将其作为ObservableCollection<Animal>而不是IOrderedEnumerable<T>添加回到animals中，因为它需要进行转换。不过我选择了Marco的解决方案。 - vapcguy/// <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来进行了改进。这应该提高性能并解决相关问题。
Move操作的答案在集合中存在重复项时无法正确工作。请参考以下链接以获取正确的实现方式：https://dev59.com/WnI-5IYBdhLWcg3wQV8Z#1945701/ - nawfal