我有以下课程：
[DataContract]
public class Pair<TKey, TValue> : INotifyPropertyChanged, IDisposable
{
public Pair(TKey key, TValue value)
{
Key = key;
Value = value;
}
#region Properties
[DataMember]
public TKey Key
{
get
{ return m_key; }
set
{
m_key = value;
OnPropertyChanged("Key");
}
}
[DataMember]
public TValue Value
{
get { return m_value; }
set
{
m_value = value;
OnPropertyChanged("Value");
}
}
#endregion
#region Fields
private TKey m_key;
private TValue m_value;
#endregion
#region INotifyPropertyChanged Members
public event PropertyChangedEventHandler PropertyChanged;
protected void OnPropertyChanged(string name)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(name));
}
}
#endregion
#region IDisposable Members
public void Dispose()
{ }
#endregion
}
我把它放在一个ObservableCollection中：
ObservableCollection<Pair<ushort, string>> my_collection =
new ObservableCollection<Pair<ushort, string>>();
my_collection.Add(new Pair(7, "aaa"));
my_collection.Add(new Pair(3, "xey"));
my_collection.Add(new Pair(6, "fty"));
问：我如何按键排序？
答案 0 :(得分：77)
这个简单的扩展对我来说很漂亮。我必须确保MyObject是IComparable。在可观察的MyObjects集合上调用sort方法时，将调用CompareTo上的MyObject方法，该方法调用我的逻辑排序方法。虽然这里没有其他答案的所有花里胡哨，但这正是我所需要的。
static class Extensions
{
public static void Sort<T>(this ObservableCollection<T> collection) where T : IComparable
{
List<T> sorted = collection.OrderBy(x => x).ToList();
for (int i = 0; i < sorted.Count(); i++)
collection.Move(collection.IndexOf(sorted[i]), i);
}
}
public class MyObject: IComparable
{
public int CompareTo(object o)
{
MyObject a = this;
MyObject b = (MyObject)o;
return Utils.LogicalStringCompare(a.Title, b.Title);
}
public string Title;
}
.
.
.
myCollection = new ObservableCollection<MyObject>();
//add stuff to collection
myCollection.Sort();
答案 1 :(得分：38)
我知道这个问题已经过时了，但是谷歌搜索时却发现了一个相关的博客条目提供了比这里更好的答案：
http://kiwigis.blogspot.com/2010/03/how-to-sort-obversablecollection.html
<强>更新
@romkyns在评论中指出的ObservableSortedList会自动维护排序顺序。
实现一个可观察的集合，该集合按排序顺序维护其项目。特别是，可以正确处理导致订单更改的商品属性的更改。
但是请注意注释
由于所涉及的界面相对复杂，文档相对较差（参见https://stackoverflow.com/a/5883947/33080），可能会出错。
答案 2 :(得分：23)
您可以使用以下简单方法：
public static void Sort<TSource, TKey>(this Collection<TSource> source, Func<TSource, TKey> keySelector)
{
List<TSource> sortedList = source.OrderBy(keySelector).ToList();
source.Clear();
foreach (var sortedItem in sortedList)
source.Add(sortedItem);
}
您可以这样排序：
_collection.Sort(i => i.Key);
更多细节：http://jaider.net/2011-05-04/sort-a-observablecollection/
答案 3 :(得分：20)
OP编辑：正如许多人已正确指出原始答案不会返回相同的集合，（最初更侧重于排序Q的字典部分）。请参阅底部的编辑，其中我解决了可观察集合的排序问题。原来离开这里仍然收到投票
您可以使用linq作为下面的doSort方法说明。快速代码段：生成
3：xey 6：FTY 7：AAA
或者，您可以对集合本身使用扩展方法
var sortedOC = _collection.OrderBy(i => i.Key);
private void doSort()
{
ObservableCollection<Pair<ushort, string>> _collection =
new ObservableCollection<Pair<ushort, string>>();
_collection.Add(new Pair<ushort,string>(7,"aaa"));
_collection.Add(new Pair<ushort, string>(3, "xey"));
_collection.Add(new Pair<ushort, string>(6, "fty"));
var sortedOC = from item in _collection
orderby item.Key
select item;
foreach (var i in sortedOC)
{
Debug.WriteLine(i);
}
}
public class Pair<TKey, TValue>
{
private TKey _key;
public TKey Key
{
get { return _key; }
set { _key = value; }
}
private TValue _value;
public TValue Value
{
get { return _value; }
set { _value = value; }
}
public Pair(TKey key, TValue value)
{
_key = key;
_value = value;
}
public override string ToString()
{
return this.Key + ":" + this.Value;
}
}
修改
要返回ObservableCollection，请使用例如 sortedOC 调用.ToObservableCollection。 this implementation
OP EDIT 对可观察量进行排序并返回相同的对象排序可以使用扩展方法完成。对于较大的收藏品，请注意收集更改通知的数量，例如
public static void Sort<T>(this ObservableCollection<T> observable) where T : IComparable<T>, IEquatable<T>
{
List<T> sorted = observable.OrderBy(x => x).ToList();
int ptr = 0;
while (ptr < sorted.Count)
{
if (!observable[ptr].Equals(sorted[ptr]))
{
T t = observable[ptr];
observable.RemoveAt(ptr);
observable.Insert(sorted.IndexOf(t), t);
}
else
{
ptr++;
}
}
}
用法： 使用观察者的示例（使用Person类来保持简单）
public class Person:IComparable<Person>,IEquatable<Person>
{
public string Name { get; set; }
public int Age { get; set; }
public int CompareTo(Person other)
{
if (this.Age == other.Age) return 0;
return this.Age.CompareTo(other.Age);
}
public override string ToString()
{
return Name + " aged " + Age;
}
public bool Equals(Person other)
{
if (this.Name.Equals(other.Name) && this.Age.Equals(other.Age)) return true;
return false;
}
}
static void Main(string[] args)
{
Console.WriteLine("adding items...");
var observable = new ObservableCollection<Person>()
{
new Person { Name = "Katy", Age = 51 },
new Person { Name = "Jack", Age = 12 },
new Person { Name = "Bob", Age = 13 },
new Person { Name = "John", Age = 14 },
new Person { Name = "Mary", Age = 41 },
new Person { Name = "Jane", Age = 20 },
new Person { Name = "Jim", Age = 39 },
new Person { Name = "Sue", Age = 15 },
new Person { Name = "Kim", Age = 19 }
};
//what do observers see?
observable.CollectionChanged += (o, e) => {
if (e.OldItems != null)
{
foreach (var item in e.OldItems)
{
Console.WriteLine("removed {0} at index {1}", item, e.OldStartingIndex);
}
}
if (e.NewItems != null)
{
foreach (var item in e.NewItems)
{
Console.WriteLine("added {0} at index {1}", item, e.NewStartingIndex);
}
}};
Console.WriteLine("\nsorting items...");
observable.Sort();
};
以上输出：
将Katy年龄51岁的Katy移除
Katy在指数8岁时加入51岁
去掉玛丽41岁的索引3
玛丽41岁时加入索引7
在指数3处删除了20岁的简
在纪念5岁时，简20岁
吉姆在指数3岁时被移除39岁
吉姆在指数6岁时加入了39岁
在指数4处删除了20岁的简
简在纪念5岁时加入了简20岁
Person类实现IComparable和IEquatable，后者用于最小化对集合的更改，以减少引发的更改通知的数量
答案 4 :(得分：15)
我喜欢上面“Richie”博客上的冒泡排序扩展方法，但我不一定只想比较整个对象。我更经常想要对对象的特定属性进行排序。所以我修改了它以按顺序接受一个键选择器，所以你可以选择要排序的属性：
public static void Sort<TSource, TKey>(this ObservableCollection<TSource> source, Func<TSource, TKey> keySelector)
{
if (source == null) return;
Comparer<TKey> comparer = Comparer<TKey>.Default;
for (int i = source.Count - 1; i >= 0; i--)
{
for (int j = 1; j <= i; j++)
{
TSource o1 = source[j - 1];
TSource o2 = source[j];
if (comparer.Compare(keySelector(o1), keySelector(o2)) > 0)
{
source.Remove(o1);
source.Insert(j, o1);
}
}
}
}
您调用OrderBy的方式与调用OrderBy的方式相同，只是它会对ObservableCollection的现有实例进行排序，而不是返回新的集合：
ObservableCollection<Person> people = new ObservableCollection<Person>();
...
people.Sort(p => p.FirstName);
答案 5 :(得分：14)
WPF使用ListCollectionView类提供现成直播 ...
public ObservableCollection<string> MyStrings { get; set; }
private ListCollectionView _listCollectionView;
private void InitializeCollection()
{
MyStrings = new ObservableCollection<string>();
_listCollectionView = CollectionViewSource.GetDefaultView(MyStrings)
as ListCollectionView;
if (_listCollectionView != null)
{
_listCollectionView.IsLiveSorting = true;
_listCollectionView.CustomSort = new
CaseInsensitiveComparer(CultureInfo.InvariantCulture);
}
}
一旦完成初始化，就没有其他事情可做了。被动排序的优势在于ListCollectionView以对开发人员透明的方式完成所有繁重工作。新项目将按正确的排序顺序自动放置。任何派生自IComparer T的类都适用于自定义排序属性。
有关文档和其他功能，请参阅ListCollectionView。
答案 6 :(得分：9)
IComparable：
static class Extensions
{
public static void Sort<TSource, TKey>(this ObservableCollection<TSource> collection, Func<TSource, TKey> keySelector)
{
List<TSource> sorted = collection.OrderBy(keySelector).ToList();
for (int i = 0; i < sorted.Count(); i++)
collection.Move(collection.IndexOf(sorted[i]), i);
}
}
现在您可以像大多数LINQ方法一样调用它：
myObservableCollection.Sort(o => o.MyProperty);
答案 7 :(得分：8)
变体是使用selection sort算法对集合进行排序的位置。使用Move方法将元素移动到位。每次移动都会触发NotifyCollectionChangedAction.Move事件Item[]（以及CollectionChanged，其属性名称为CollectionChanged）。
这个算法有一些不错的属性：
IComparable<T>个事件）几乎总是比插入排序和冒泡排序等其他类似算法少。算法非常简单。迭代该集合以找到最小元素，然后将其移动到集合的开头。从第二个元素开始重复该过程，依此类推，直到所有元素都移动到位。该算法效率不高，但对于您要在用户界面中显示的任何内容，它都无关紧要。但是，就移动操作的数量而言，它非常有效。
这是一种扩展方法，为简单起见，要求元素实现IComparer<T>。其他选项使用Func<T, T, Int32>或public static class ObservableCollectionExtensions {
public static void Sort<T>(this ObservableCollection<T> collection) where T : IComparable<T> {
if (collection == null)
throw new ArgumentNullException("collection");
for (var startIndex = 0; startIndex < collection.Count - 1; startIndex += 1) {
var indexOfSmallestItem = startIndex;
for (var i = startIndex + 1; i < collection.Count; i += 1)
if (collection[i].CompareTo(collection[indexOfSmallestItem]) < 0)
indexOfSmallestItem = i;
if (indexOfSmallestItem != startIndex)
collection.Move(indexOfSmallestItem, startIndex);
}
}
}
。
var collection = new ObservableCollection<String>(...);
collection.Sort();
对集合进行排序只需要调用扩展方法：
{{1}}
答案 8 :(得分：8)
我想添加到NeilW的回答。合并一个类似于orderby的方法。将此方法添加为扩展名：
public static void Sort<T>(this ObservableCollection<T> collection, Func<T,T> keySelector) where T : IComparable
{
List<T> sorted = collection.OrderBy(keySelector).ToList();
for (int i = 0; i < sorted.Count(); i++)
collection.Move(collection.IndexOf(sorted[i]), i);
}
并使用如下：
myCollection = new ObservableCollection<MyObject>();
//Sorts in place, on a specific Func<T,T>
myCollection.Sort(x => x.ID);
答案 9 :(得分：4)
为了改善xr280xr上的扩展方法，我添加了一个可选的bool参数来确定排序是否正在降序。我还包括卡洛斯P在对该答案的评论中提出的建议。请看下面。
public static void Sort<TSource, TKey>(this ObservableCollection<TSource> source, Func<TSource, TKey> keySelector, bool desc = false)
{
if (source == null) return;
Comparer<TKey> comparer = Comparer<TKey>.Default;
for (int i = source.Count - 1; i >= 0; i--)
{
for (int j = 1; j <= i; j++)
{
TSource o1 = source[j - 1];
TSource o2 = source[j];
int comparison = comparer.Compare(keySelector(o1), keySelector(o2));
if (desc && comparison < 0)
source.Move(j, j - 1);
else if (!desc && comparison > 0)
source.Move(j - 1, j);
}
}
}
答案 10 :(得分：2)
您是否需要始终对收藏品进行分类？检索对时，您是否需要始终对它们进行排序，或者只需要几次（可能只是为了呈现）？您对收藏品的期望有多大？有很多因素可以帮助你决定使用巫法。
如果您需要始终对集合进行排序，即使您插入或删除元素并且插入速度不是问题，也许您应该实现某种SortedObservableCollection，如@Gerrie Schenck提到或查看{ {3}}
如果您需要将您的收藏品分类几次，请使用：
my_collection.OrderBy(p => p.Key);
这需要一些时间来对集合进行排序，但即便如此，它可能是最佳解决方案，具体取决于您使用它做什么。
答案 11 :(得分：2)
我目前的答案已经获得了最多的选票，但我找到了一种更好，更现代的方式。
class MyObject
{
public int id { get; set; }
public string title { get; set; }
}
ObservableCollection<MyObject> myCollection = new ObservableCollection<MyObject>();
//add stuff to collection
// .
// .
// .
myCollection = new ObservableCollection<MyObject>(
myCollection.OrderBy(n => n.title, Comparer<string>.Create(
(x, y) => (Utils.Utils.LogicalStringCompare(x, y)))));
答案 12 :(得分：1)
到底是什么，我会把一个快速拼凑在一起的答案放在一起......它看起来有点像其他一些实现，但是我会添加它：
（几乎没有经过测试，希望我自己不会尴尬）
让我们先说明一些目标（我的假设）：
1）必须对ObservableCollection<T>进行排序，以维护通知等。
2）一定不能非常低效（即关闭到标准的“良好”分类效率）
public static class Ext
{
public static void Sort<T>(this ObservableCollection<T> src)
where T : IComparable<T>
{
// Some preliminary safety checks
if(src == null) throw new ArgumentNullException("src");
if(!src.Any()) return;
// N for the select,
// + ~ N log N, assuming "smart" sort implementation on the OrderBy
// Total: N log N + N (est)
var indexedPairs = src
.Select((item,i) => Tuple.Create(i, item))
.OrderBy(tup => tup.Item2);
// N for another select
var postIndexedPairs = indexedPairs
.Select((item,i) => Tuple.Create(i, item.Item1, item.Item2));
// N for a loop over every element
var pairEnum = postIndexedPairs.GetEnumerator();
pairEnum.MoveNext();
for(int idx = 0; idx < src.Count; idx++, pairEnum.MoveNext())
{
src.RemoveAt(pairEnum.Current.Item1);
src.Insert(idx, pairEnum.Current.Item3);
}
// (very roughly) Estimated Complexity:
// N log N + N + N + N
// == N log N + 3N
}
}
答案 13 :(得分：1)
这就是我对OC扩展的处理方式：
/// <summary>
/// Synches the collection items to the target collection items.
/// This does not observe sort order.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The items.</param>
/// <param name="updatedCollection">The updated collection.</param>
public static void SynchCollection<T>(this IList<T> source, IEnumerable<T> updatedCollection)
{
// Evaluate
if (updatedCollection == null) return;
// Make a list
var collectionArray = updatedCollection.ToArray();
// Remove items from FilteredViewItems not in list
source.RemoveRange(source.Except(collectionArray));
// Add items not in FilteredViewItems that are in list
source.AddRange(collectionArray.Except(source));
}
/// <summary>
/// Synches the collection items to the target collection items.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The source.</param>
/// <param name="updatedCollection">The updated collection.</param>
/// <param name="canSort">if set to <c>true</c> [can sort].</param>
public static void SynchCollection<T>(this ObservableCollection<T> source,
IList<T> updatedCollection, bool canSort = false)
{
// Synch collection
SynchCollection(source, updatedCollection.AsEnumerable());
// Sort collection
if (!canSort) return;
// Update indexes as needed
for (var i = 0; i < updatedCollection.Count; i++)
{
// Index of new location
var index = source.IndexOf(updatedCollection[i]);
if (index == i) continue;
// Move item to new index if it has changed.
source.Move(index, i);
}
}
答案 14 :(得分：1)
这对我有用，很久以前就发现了。
// SortableObservableCollection
public class SortableObservableCollection<T> : ObservableCollection<T>
{
public SortableObservableCollection(List<T> list)
: base(list)
{
}
public SortableObservableCollection()
{
}
public void Sort<TKey>(Func<T, TKey> keySelector, System.ComponentModel.ListSortDirection direction)
{
switch (direction)
{
case System.ComponentModel.ListSortDirection.Ascending:
{
ApplySort(Items.OrderBy(keySelector));
break;
}
case System.ComponentModel.ListSortDirection.Descending:
{
ApplySort(Items.OrderByDescending(keySelector));
break;
}
}
}
public void Sort<TKey>(Func<T, TKey> keySelector, IComparer<TKey> comparer)
{
ApplySort(Items.OrderBy(keySelector, comparer));
}
private void ApplySort(IEnumerable<T> sortedItems)
{
var sortedItemsList = sortedItems.ToList();
foreach (var item in sortedItemsList)
{
Move(IndexOf(item), sortedItemsList.IndexOf(item));
}
}
}
用法：
MySortableCollection.Sort(x => x, System.ComponentModel.ListSortDirection.Ascending);
答案 15 :(得分：1)
好吧，因为我在使用ObservableSortedList与XAML一起工作时遇到了问题，所以我继续创建了SortingObservableCollection。它继承自ObservableCollection，因此它可以与XAML一起工作，并且我已经对它进行了单元测试，以达到98％的代码覆盖率。我在我自己的应用程序中使用过它，但我不会保证它没有bug。随意贡献。以下是示例代码用法：
var collection = new SortingObservableCollection<MyViewModel, int>(Comparer<int>.Default, model => model.IntPropertyToSortOn);
collection.Add(new MyViewModel(3));
collection.Add(new MyViewModel(1));
collection.Add(new MyViewModel(2));
// At this point, the order is 1, 2, 3
collection[0].IntPropertyToSortOn = 4; // As long as IntPropertyToSortOn uses INotifyPropertyChanged, this will cause the collection to resort correctly
它是PCL，因此它适用于Windows应用商店，Windows Phone和.NET 4.5.1。
答案 16 :(得分：1)
这些答案都不适用于我的案例。无论是因为它搞砸了绑定，还是需要这么多额外的编码才能成为一场噩梦，或者答案刚刚被打破。所以，这是我想到的另一个更简单的答案。这是一个更少的代码，它仍然是相同的可观察集合与另一个this.sort类型的方法。让我知道，如果有一些原因我不应该这样做（效率等）？
public class ScoutItems : ObservableCollection<ScoutItem>
{
public void Sort(SortDirection _sDir, string _sItem)
{
//TODO: Add logic to look at _sItem and decide what property to sort on
IEnumerable<ScoutItem> si_enum = this.AsEnumerable();
if (_sDir == SortDirection.Ascending)
{
si_enum = si_enum.OrderBy(p => p.UPC).AsEnumerable();
} else
{
si_enum = si_enum.OrderByDescending(p => p.UPC).AsEnumerable();
}
foreach (ScoutItem si in si_enum)
{
int _OldIndex = this.IndexOf(si);
int _NewIndex = si_enum.ToList().IndexOf(si);
this.MoveItem(_OldIndex, _NewIndex);
}
}
}
...... ScoutItem是我的公共课。看起来简单得多了。增加了好处：它实际上有效并且不会破坏绑定或返回新的集合等。
答案 17 :(得分：1)
创建一个新课程SortedObservableCollection，从ObservableCollection派生并实施IComparable<Pair<ushort, string>>。
答案 18 :(得分：1)
我认为这是最优雅的解决方案：
答案 19 :(得分：1)
一种方法是将其转换为List，然后调用Sort（），提供比较委托。类似的东西： -
（未测试的）
my_collection.ToList().Sort((left, right) => left == right ? 0 : (left > right ? -1 : 1));
答案 20 :(得分：0)
我需要能够按多种方式排序，而不仅仅是一种。这个答案基于其他一些答案，但它允许更复杂的排序。
Children.Sort(col => col.OrderByDescending(xx => xx.ItemType == "drive")
.ThenByDescending(xx => xx.ItemType == "folder")
.ThenBy(xx => xx.Path));
使用它时，传递一系列OrderBy / ThenBy调用。像这样：
var audio = document.getElementById('audioElement');
audio.ontimeupdate = function () {
setInterval(function(){
console.log("test");
}, 1000);
};答案 21 :(得分：0)
我从其他解决方案中学到了很多，但是发现了两个问题。首先，有些依赖于IndexOf，对于大型列表，它往往非常慢。其次，我的ObservableCollection具有EF实体，使用Remove似乎破坏了某些外键属性。也许我做错了。
无论如何，可以使用“移动”代替“删除/插入”，但这会导致性能修复出现一些问题。
为解决性能问题，我用IndexOf排序值创建了一个字典。为了使字典保持最新状态并保留实体属性，请使用通过两次移动实现的交换，而不是在其他解决方案中实现的一次交换。
单步移动在位置之间移动元素的索引，这将使IndexOf字典无效。添加第二步以实现交换可恢复位置。
public static void Sort<TSource, TKey>(this ObservableCollection<TSource> collection, Func<TSource, TKey> keySelector)
{
List<TSource> sorted = collection.OrderBy(keySelector).ToList();
Dictionary<TSource, int> indexOf = new Dictionary<TSource, int>();
for (int i = 0; i < sorted.Count; i++)
indexOf[sorted[i]] = i;
int idx = 0;
while (idx < sorted.Count)
if (!collection[idx].Equals(sorted[idx])) {
int newIdx = indexOf[collection[idx]]; // where should current item go?
collection.Move(newIdx, idx); // move whatever's there to current location
collection.Move(idx + 1, newIdx); // move current item to proper location
}
else {
idx++;
}
}
答案 22 :(得分：-3)
var collection = new ObservableCollection<int>();
collection.Add(7);
collection.Add(4);
collection.Add(12);
collection.Add(1);
collection.Add(20);
// ascending
collection = new ObservableCollection<int>(collection.OrderBy(a => a));
// descending
collection = new ObservableCollection<int>(collection.OrderByDescending(a => a));