How do I sort an observable collection

Question

I have a following class     DataContract  public class Pair lt TKey  TValue gt    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     Which I ve put in an ObservableCollection    ObservableCollection lt Pair lt ushort  string gt  gt  my collection        new ObservableCollection lt Pair lt ushort  string gt  gt      my collection Add new Pair 7   aaa     my collection Add new Pair 3   xey     my collection Add new Pair 6   fty       Q   How do I sort it by key

User · Answer

Alright  since I was having issues getting ObservableSortedList to work with XAML  I went ahead and created SortingObservableCollection  It inherits from ObservableCollection  so it works with XAML and I ve unit tested it to 98  code coverage  I ve used it in my own apps  but I won t promise that it is bug free  Feel free to contribute  Here is sample code usage   var collection   new SortingObservableCollection lt MyViewModel  int gt  Comparer lt int gt  Default  model   gt  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   It s a PCL  so it should work with Windows Store  Windows Phone  and  NET 4 5 1

User · Answer

I found a relevant blog entry that provides a better answer than the ones here   http   kiwigis blogspot com 2010 03 how-to-sort-obversablecollection html  UPDATE  The ObservableSortedList that  romkyns points out in the comments automatically maintains sort order      Implements an observable collection which maintains its items in sorted order  In particular  changes to item properties that result in order changes are handled correctly    However note also the remark     May be buggy due to the comparative complexity of the interface involved and its relatively poor documentation  see https   stackoverflow com a 5883947 33080

User · Answer

None of these answers worked in my case  Either because it screws up binding  or requires so much additional coding that it s kind of a nightmare  or the answer is just broken  So  here s yet another simpler answer i thought  It s a lot less code and it remains the same observable collection with an additional this sort type of method  Let me know if there s some reason I shouldn t be doing it this way  efficiency etc     public class ScoutItems   ObservableCollection lt ScoutItem gt        public void Sort SortDirection  sDir  string  sItem                       TODO  Add logic to look at  sItem and decide what property to sort on             IEnumerable lt ScoutItem gt  si enum   this AsEnumerable                 if   sDir    SortDirection Ascending                                si enum   si enum OrderBy p   gt  p UPC  AsEnumerable                  else                               si enum   si enum OrderByDescending p   gt  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                                Where ScoutItem is my public class  Just seemed a lot simpler  Added benefit  it actually  works and doesn t mess with bindings or return a new collection etc

User · Answer

This simple extension worked beautifully for me   I just had to make sure that MyObject was IComparable   When the sort method is called on the observable collection of MyObjects  the CompareTo method on MyObject is called  which calls my Logical Sort method   While it doesn t have all the bells and whistles of the rest of the answers posted here  it s exactly what I needed   static class Extensions       public static void Sort lt T gt  this ObservableCollection lt T gt  collection  where T   IComparable               List lt T gt  sorted   collection OrderBy x   gt  x  ToList            for  int i   0  i  lt  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 lt MyObject gt       add stuff to collection myCollection Sort

User · Answer

I liked the bubble sort extension method approach on  Richie  s blog above  but I don t necessarily want to just sort comparing the entire object  I more often want to sort on a specific property of the object  So I modified it to accept a key selector the way OrderBy does so you can choose which property to sort on       public static void Sort lt TSource  TKey gt  this ObservableCollection lt TSource gt  source  Func lt TSource  TKey gt  keySelector                if  source    null  return           Comparer lt TKey gt  comparer   Comparer lt TKey gt  Default           for  int i   source Count - 1  i  gt   0  i--                        for  int j   1  j  lt   i  j                                  TSource o1   source j - 1                   TSource o2   source j                   if  comparer Compare keySelector o1   keySelector o2    gt  0                                        source Remove o1                       source Insert j  o1                                                     Which you would call the same way you would call OrderBy except it will sort the existing instance of your ObservableCollection instead of returning a new collection   ObservableCollection lt Person gt  people   new ObservableCollection lt Person gt          people Sort p   gt  p FirstName

User · Answer

This is what I do with OC extensions            lt summary gt          Synches the collection items to the target collection items          This does not observe sort order           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  source  gt The items  lt  param gt           lt param name  updatedCollection  gt The updated collection  lt  param gt      public static void SynchCollection lt T gt  this IList lt T gt  source  IEnumerable lt T gt  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                    lt summary gt          Synches the collection items to the target collection items           lt  summary gt           lt typeparam name  T  gt  lt  typeparam gt           lt param name  source  gt The source  lt  param gt           lt param name  updatedCollection  gt The updated collection  lt  param gt           lt param name  canSort  gt if set to  lt c gt true lt  c gt   can sort   lt  param gt      public static void SynchCollection lt T gt  this ObservableCollection lt T gt  source          IList lt T gt  updatedCollection  bool canSort   false                   Synch collection         SynchCollection source  updatedCollection AsEnumerable                 Sort collection         if   canSort  return              Update indexes as needed         for  var i   0  i  lt  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

User · Answer

To improve a little bit the extension method on xr280xr answer I added an optional bool parameter to determine whether the sorting is descending or not  I also included the suggestion made by Carlos P in the comment to that answer  Please see below    public static void Sort lt TSource  TKey gt  this ObservableCollection lt TSource gt  source  Func lt TSource  TKey gt  keySelector  bool desc   false                if  source    null  return           Comparer lt TKey gt  comparer   Comparer lt TKey gt  Default           for  int i   source Count - 1  i  gt   0  i--                        for  int j   1  j  lt   i  j                                  TSource o1   source j - 1                   TSource o2   source j                   int comparison   comparer Compare keySelector o1   keySelector o2                    if  desc  amp  amp  comparison  lt  0                      source Move j  j - 1                   else if   desc  amp  amp  comparison  gt  0                      source Move j - 1  j

User · Answer

WPF provides live sorting out-of-the-box using the ListCollectionView class     public ObservableCollection lt string gt  MyStrings   get  set    private ListCollectionView  listCollectionView  private void InitializeCollection         MyStrings   new ObservableCollection lt string gt          listCollectionView   CollectionViewSource GetDefaultView MyStrings                 as ListCollectionView      if   listCollectionView    null                 listCollectionView IsLiveSorting   true           listCollectionView CustomSort   new                  CaseInsensitiveComparer CultureInfo InvariantCulture             Once this initialization is complete  there s nothing more to do  The advantage over a passive sort is that the ListCollectionView does all the heavy lifting in a way that s transparent to the developer   New items are automatically placed in their correct sort order   Any class that derives from IComparer of T is suitable for the custom sort property   See ListCollectionView for the documentation and other features

User · Answer

I needed to be able to sort by multiple things not just one  This answer is based on some of the other answers but it allows for more complex sorting   static class Extensions       public static void Sort lt T  TKey gt  this ObservableCollection lt T gt  collection  Func lt ObservableCollection lt T gt   TKey gt  sort                var sorted    sort Invoke collection  as IOrderedEnumerable lt T gt   ToArray            for  int i   0  i  lt  sorted Count    i                collection Move collection IndexOf sorted i    i             When you use it  pass in a series of OrderBy ThenBy calls  Like this   Children Sort col   gt  col OrderByDescending xx   gt  xx ItemType     drive                        ThenByDescending xx   gt  xx ItemType     folder                        ThenBy xx   gt  xx Path

User · Answer

I learned a lot from the other solutions  but I found a couple of problems   First  some depend on IndexOf which tends to be pretty slow for large lists   Second  my ObservableCollection had EF entities and using the Remove seemed to corrupt some of the foreign key properties  Maybe I m doing something wrong     Regardless  A Move can be used instead Remove Insert  but that causes some issues with the performance fix   To fix the performance problem  I create a dictionary with the IndexOf sorted values   To keep the dictionary up-to-date and to preserve the entity properties  use a swap implemented with two moves instead of one as implemented in other solutions   A single move shifts the indexes of the elements between the locations  which would invalidate the IndexOf dictionary   Adding a second move to implement a swap restores locations   public static void Sort lt TSource  TKey gt  this ObservableCollection lt TSource gt  collection  Func lt TSource  TKey gt  keySelector        List lt TSource gt  sorted   collection OrderBy keySelector  ToList        Dictionary lt TSource  int gt  indexOf   new Dictionary lt TSource  int gt          for  int i   0  i  lt  sorted Count  i            indexOf sorted i     i       int idx   0      while  idx  lt  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

User · Answer

My current answer already has the most votes  but I found a better  and more modern  way of doing this   class MyObject          public int id   get  set          public string title   get  set       ObservableCollection lt MyObject gt  myCollection   new ObservableCollection lt MyObject gt        add stuff to collection                 myCollection   new ObservableCollection lt MyObject gt       myCollection OrderBy n   gt  n title  Comparer lt string gt  Create       x  y    gt   Utils Utils LogicalStringCompare x  y

User · Answer

This worked for me  found it long time ago somewhere      SortableObservableCollection public class SortableObservableCollection lt T gt    ObservableCollection lt T gt                public SortableObservableCollection List lt T gt  list                base list                               public SortableObservableCollection                                public void Sort lt TKey gt  Func lt T  TKey gt  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 lt TKey gt  Func lt T  TKey gt  keySelector  IComparer lt TKey gt  comparer                        ApplySort Items OrderBy keySelector  comparer                       private void ApplySort IEnumerable lt T gt  sortedItems                        var sortedItemsList   sortedItems ToList                 foreach  var item in sortedItemsList                                Move IndexOf item   sortedItemsList IndexOf item                                    Usage   MySortableCollection Sort x   gt  x  System ComponentModel ListSortDirection Ascending

User · Answer

NielW s answer is the way to go  for real in-place sorting   I wanted to add an slightly altered solution that allows you bypass having to use IComparable   static class Extensions       public static void Sort lt TSource  TKey gt  this ObservableCollection lt TSource gt  collection  Func lt TSource  TKey gt  keySelector                List lt TSource gt  sorted   collection OrderBy keySelector  ToList            for  int i   0  i  lt  sorted Count    i                collection Move collection IndexOf sorted i    i             now you can call it like most any LINQ method   myObservableCollection Sort o   gt  o MyProperty

User · Answer

One way would be to convert it to a List and then call Sort    providing a comparison delegate   Something like -   untested   my collection ToList   Sort  left  right    gt  left    right   0    left  gt  right   -1   1

User · Answer

Do you need to keep your collection sorted at all times  When retrieving the pairs  do you need them to be always sorted  or it s only for a few times  maybe just for presenting   How big do you expect your collection to be  There are a lot of factors that can help you decide witch method to use   If you need the collection to be sorted at all times  even when you insert or delete elements and insertion speed is not a problem maybe you should implement some kind of SortedObservableCollection like  Gerrie Schenck mentioned or check out this implementation   If you need your collection sorted just for a few times use   my collection OrderBy p   gt  p Key     This will take some time to sort the collection  but even so  it might be the best solution depending on what your doing with it

User · Answer

I would like to Add to NeilW s answer  To incorporate a method that resembles the orderby  Add this method as an extension   public static void Sort lt T gt  this ObservableCollection lt T gt  collection  Func lt T T gt  keySelector  where T   IComparable       List lt T gt  sorted   collection OrderBy keySelector  ToList        for  int i   0  i  lt  sorted Count    i            collection Move collection IndexOf sorted i    i       And use like   myCollection   new ObservableCollection lt MyObject gt        Sorts in place  on a specific Func lt T T gt  myCollection Sort x   gt  x ID

User · Answer

Make a new class SortedObservableCollection  derive it from ObservableCollection and implement IComparable lt Pair lt ushort  string gt  gt

User · Answer

A variation is where you sort the collection in place using a selection sort algorithm  Elements are moved into place using the Move method  Each move will fire the CollectionChanged event with NotifyCollectionChangedAction Move  and also PropertyChanged with property name Item      This algorithm has some nice properties    The algorithm can be implemented as a stable sort  The number of items moved in the collection  e g  CollectionChanged events fired  is almost always less than other similar algorithms like insertion sort and bubble sort    The algorithm is quite simple  The collection is iterated to find the smallest element which is then moved to the start of the collection  The process is repeated starting at the second element and so on until all elements have been moved into place  The algorithm is not terribly efficient but for anything you are going to display in a user interface it shouldn t matter  However  in terms of the number of move operations it is quite efficient   Here is an extension method that for simplicity requires that the elements implement IComparable lt T gt   Other options are using an IComparer lt T gt  or a Func lt T  T  Int32 gt    public static class ObservableCollectionExtensions      public static void Sort lt T gt  this ObservableCollection lt T gt  collection  where T   IComparable lt T gt        if  collection    null        throw new ArgumentNullException  collection         for  var startIndex   0  startIndex  lt  collection Count - 1  startIndex    1          var indexOfSmallestItem   startIndex        for  var i   startIndex   1  i  lt  collection Count  i    1          if  collection i  CompareTo collection indexOfSmallestItem    lt  0            indexOfSmallestItem   i        if  indexOfSmallestItem    startIndex          collection Move indexOfSmallestItem  startIndex                  Sorting a collection is simply a matter of invoking the extension method   var collection   new ObservableCollection lt String gt        collection Sort

User · Answer

Sorting an observable and returning the same object sorted can be done using an extension method  For larger collections watch out for the number of collection changed notifications  I have updated my code to improve performance  thanks to nawfal  and to handle duplicates which no other answers here do at time of writing  The observable is partitioned into a left sorted half and a right unsorted half  where each time the minimum item  as found in the sorted list  is shifted to the end of the sorted partition from the unsorted  Worst case O n   Essentially a selection sort  See below for output   public static void Sort lt T gt  this ObservableCollection lt T gt  collection          where T   IComparable lt T gt   IEquatable lt T gt                List lt T gt  sorted   collection OrderBy x   gt  x  ToList             int ptr   0          while  ptr  lt  sorted Count - 1                        if   collection ptr  Equals sorted ptr                                  int idx   search collection  ptr 1  sorted ptr                    collection Move idx  ptr                                          ptr                         public static int search lt T gt  ObservableCollection lt T gt  collection  int startIndex  T other                                for  int i   startIndex  i  lt  collection Count  i                                          if  other Equals collection i                            return i                                         return -1     decide how to handle error case                usage  Sample with an observer  used a Person class to keep it simple      public class Person IComparable lt Person gt  IEquatable lt Person gt                                 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    quot  aged  quot    Age                                         public bool Equals Person other                                        if  this Name Equals other Name   amp  amp  this Age Equals other Age   return true                      return false                                                 static void Main string   args                                Console WriteLine  quot adding items    quot                    var observable   new ObservableCollection lt Person gt                                          new Person  Name    quot Katy quot   Age   51                       new Person  Name    quot Jack quot   Age   12                       new Person  Name    quot Bob quot   Age   13                       new Person  Name    quot Alice quot   Age   39                       new Person  Name    quot John quot   Age   14                       new Person  Name    quot Mary quot   Age   41                       new Person  Name    quot Jane quot   Age   20                       new Person  Name    quot Jim quot   Age   39                       new Person  Name    quot Sue quot   Age   5                       new Person  Name    quot Kim quot   Age   19                                            what do observers see                    observable CollectionChanged     sender  e    gt                        Console WriteLine                  e OldItems 0     quot  move from  quot    e OldStartingIndex    quot  to  quot    e NewStartingIndex               int i   0              foreach  var person in sender as ObservableCollection lt Person gt                                 if  i    e NewStartingIndex                                        Console Write  quot   quot     person as Person  Age    quot    quot                                      else                                       Console Write  person as Person  Age    quot   quot                                                       i                               Console WriteLine                Details of sorting progress showing how the collection is pivoted  Sue aged 5 move from 8 to 0  5  51 12 13 39 14 41 20 39 19  Jack aged 12 move from 2 to 1 5  12  51 13 39 14 41 20 39 19  Bob aged 13 move from 3 to 2 5 12  13  51 39 14 41 20 39 19  John aged 14 move from 5 to 3 5 12 13  14  51 39 41 20 39 19  Kim aged 19 move from 9 to 4 5 12 13 14  19  51 39 41 20 39  Jane aged 20 move from 8 to 5 5 12 13 14 19  20  51 39 41 39  Alice aged 39 move from 7 to 6 5 12 13 14 19 20  39  51 41 39  Jim aged 39 move from 9 to 7 5 12 13 14 19 20 39  39  51 41  Mary aged 41 move from 9 to 8 5 12 13 14 19 20 39 39  41  51   The Person class implements both IComparable and IEquatable the latter is used to minimise the changes to the collection so as to reduce the number of change notifications raised  EDIT Sorts same collection without creating a new copy     To return an ObservableCollection  call  ToObservableCollection on  sortedOC  using e g   this implementation  1        orig answer - this creates a new collection      You can use linq as the doSort method below illustrates  A quick code snippet  produces 3 xey 6 fty 7 aaa Alternatively you could use an extension method on the collection itself var sortedOC    collection OrderBy i   gt  i Key    private void doSort         ObservableCollection lt Pair lt ushort  string gt  gt   collection            new ObservableCollection lt Pair lt ushort  string gt  gt           collection Add new Pair lt ushort string gt  7  quot aaa quot          collection Add new Pair lt ushort  string gt  3   quot xey quot          collection Add new Pair lt ushort  string gt  6   quot fty quot          var sortedOC   from item in  collection                    orderby item Key                    select item       foreach  var i in sortedOC                Debug WriteLine i             public class Pair lt TKey  TValue gt        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    quot   quot    this Value

User · Answer

You can use this simple method  public static void Sort lt TSource  TKey gt  this Collection lt TSource gt  source  Func lt TSource  TKey gt  keySelector        List lt TSource gt  sortedList   source OrderBy keySelector  ToList        source Clear        foreach  var sortedItem in sortedList          source Add sortedItem      You can sort like this   collection Sort i   gt  i Key

User · Answer

var collection   new ObservableCollection lt int gt      collection Add 7   collection Add 4   collection Add 12   collection Add 1   collection Add 20       ascending collection   new ObservableCollection lt int gt  collection OrderBy a   gt  a        descending collection   new ObservableCollection lt int gt  collection OrderByDescending a   gt  a

User · Answer

What the heck  I ll throw in a quickly-cobbled-together answer as well   it looks a bit like some other implementations here  but I ll add it anywho    barely tested  hopefully I m not embarassing myself   Let s state some goals first  my assumptions    1  Must sort ObservableCollection lt T gt  in place  to maintain notifications  etc   2  Must not be horribly inefficient  i e   something close to standard  good  sorting efficiency   public static class Ext       public static void Sort lt T gt  this ObservableCollection lt T gt  src          where T   IComparable lt T gt                   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    gt  Tuple Create i  item                OrderBy tup   gt  tup Item2              N for another select         var postIndexedPairs   indexedPairs              Select  item i    gt  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  lt  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

[c#] How do I sort an observable collection?

Examples related to c#

Examples related to .net

Examples related to wpf

Examples related to sorting

Examples related to observablecollection