Sort ObservableCollection string through C

Question

I have below ObservableCollection lt string gt   I need to sort this alphabetically   private ObservableCollection lt string gt   animals   new ObservableCollection lt string gt         Cat    Dog    Bear    Lion    Mouse        Horse    Rat    Elephant    Kangaroo    Lizard         Snake    Frog    Fish    Butterfly    Human         Cow    Bumble Bee       I tried  animals OrderByDescending  But I don t know how to use it correctly    animals OrderByDescending a   gt  a  lt what is here   gt      How can I do this

User · Answer

I did a sort on a certain class field  distance    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 lt RateInfo gt  Phones   get  set     public List lt RateInfo gt  LRate   get  set     public ObservableCollection lt RateInfo gt  Phones   get  set     public List lt RateInfo gt  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    gt  x distance CompareTo y distance             foreach  var item in LRate                        Phones Add item

User · Answer

Here is a slight variation on Shimmy s one for collection of classes that already implement the well-known IComparable lt T gt  interface  In this case  the  order by  selector is implicit   public class SortedObservableCollection lt T gt    ObservableCollection lt T gt  where T   IComparable lt T gt        protected override void OnCollectionChanged NotifyCollectionChangedEventArgs e                base OnCollectionChanged e           if  e Action    NotifyCollectionChangedAction Reset  amp  amp              e Action    NotifyCollectionChangedAction Move  amp  amp              e Action    NotifyCollectionChangedAction Remove                        var query   this Select  item  index    gt   Item  item  Index  index   OrderBy tuple   gt  tuple Item  Comparer Default               var map   query Select  tuple  index    gt   OldIndex  tuple Index  NewIndex  index   Where o   gt  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    gt  throw new InvalidOperationException        protected override void SetItem int index  T item    gt  throw new InvalidOperationException         private class Comparer   IComparer lt T gt                public static readonly Comparer Default   new Comparer             public int Compare T x  T y    gt  x CompareTo y                 explicit sort  sometimes needed      public virtual void Sort                 if  Items Count  lt   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

User · Answer

This is an ObservableCollection lt T gt   that automatically sorts itself upon a change  triggers a sort only when necessary  and only triggers a single move collection change action   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 lt T gt    ObservableCollection lt T gt          public Func lt T  object gt  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    gt   Item  item  Index  index          query   Descending           query OrderBy tuple   gt  SortingSelector tuple Item             query OrderByDescending tuple   gt  SortingSelector tuple Item           var map   query Select  tuple  index    gt   OldIndex tuple Index  NewIndex index           Where o   gt  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 lt int gt      SortingSelector   i   gt  i          xx CollectionChanged     sender  e    gt         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                     Output   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

User · Answer

myObservableCollection ToList   Sort  x  y    gt  x Property CompareTo y Property

User · Answer

I would like to share my thoughts as well  since I ve bumped into the same issue  Well  just answering the question would be  1 - Add an extenssion to the observable collection class like this  namespace YourNameSpace       public static class ObservableCollectionExtension               public static void OrderByReference lt T gt  this ObservableCollection lt T gt  collection  List lt T gt  comparison                        for  int i   0  i  lt  comparison Count  i                                  if   comparison ElementAt i  Equals collection ElementAt i                        collection Move collection IndexOf comparison i    i                                            public static void InsertInPlace lt T gt  this ObservableCollection lt T gt  collection  List lt T gt  comparison  T item                        int index   comparison IndexOf item               comparison RemoveAt index               collection OrderByReference comparison               collection Insert index  item                      2 - Then use it like this   animals OrderByReference  animals OrderBy x   gt  x  ToList      This changes your ObservableCollection  you can use linq and it doesn t change the bindings  Extra  I ve extended  Marco and  Contango answers to my own liking  First I thought of using a list directly as the comparison  so you would have this  public static void OrderByReference lt T gt  this ObservableCollection lt T gt  collection  List lt T gt  comparison        for  int i   0  i  lt  comparison Count  i                  collection Move collection IndexOf comparison i    i            And using like this  YourObservableCollection OrderByReference YourObservableCollection DoYourLinqOrdering   ToList      Then I ve thought  since this always move everything and triggers the move in the ObservableCollection why not compare if the object is already in there  and this brings what I ve put in the begining with the Equals comparator  Adding the object to the correct place also sounded good  but I wanned a simple way to do it  So I ve came up with that  public static void InsertInPlace lt T gt  this ObservableCollection lt T gt  collection  List lt T gt  comparison  T item        collection Insert comparison IndexOf item   item      You send a list with the new object where you want and also this new object  so you need to create a list  then add this new object  like this  var YourList   YourObservableCollection ToList    var YourObject   new YourClass            YourList Add YourObject   YourObservableCollection InsertInPlace YourList DoYourLinqOrdering   ToList    YourObject    But since the ObservableCollection could be in a different order than the list because of the selection in the  quot DoYourLinqOrdering   quot   this would happen if the collection wasn t previously ordered  I ve added the first extession  OrderByReference  in the insert as you can see in the begining of the answer  It will not take long if it doesn t need to move the itens arround  so I did t saw a problem in using it  As performance goes  I ve compared the methods by checking the time it takes for each to finish  so not ideal  but anyway  I ve tested an observable collection with 20000 itens  For the OrderByReference I didn t saw great difference in the performance by adding the Equal object checker  but if not all itens need to be moved it is faster and it doesn t fire unecessary Move events on the collecitonChanged  so thats something  For the InsertInPlace is the same thing  if the ObservableCollection is already sorted  just checking if the objects are in the right place is faster than moving all the itens around  so there was not a huge difference in time if it is just passing through the Equals statement and you get the benefit of being sure everything is where it should be  Be aware that if you use this extession with objects that dont mach or with a list that have more or less objects you will get an ArgumentOutOfRangeException or some other unexpect behaviour  Hopes this helps somebody

User · Answer

The argument to OrderByDescending is a function returning a key to sort with  In your case  the key is the string itself   var result    animals OrderByDescending a   gt  a     If you wanted to sort by length for example  you ll write   var result    animals OrderByDescending a   gt  a Length

User · Answer

I looked at these  I was getting it sorted  and then it broke the binding  as above   Came up with this solution  though simpler than most of yours  it appears to do what I want to     public static ObservableCollection lt string gt  OrderThoseGroups  ObservableCollection lt string gt  orderThoseGroups                ObservableCollection lt string gt  temp          temp    new ObservableCollection lt string gt  orderThoseGroups OrderBy p   gt  p            orderThoseGroups Clear            foreach  string j in temp  orderThoseGroups Add j           return orderThoseGroups

User · Answer

I know this is an old question  but is the first google result for  sort observablecollection  so thought it worth to leave my two cent   The way  The way I would go is to build a List lt  gt  starting from the ObservableCollection lt  gt   sort it  through its Sort   method  more on msdn  and when the List lt  gt  has been sorted  reorder the ObservableCollection lt  gt  with the Move   method   The code  public static void Sort lt T gt  this ObservableCollection lt T gt  collection  Comparison lt T gt  comparison        var sortableList   new List lt T gt  collection       sortableList Sort comparison        for  int i   0  i  lt  sortableList Count  i                  collection Move collection IndexOf sortableList i    i             The test  public void TestObservableCollectionSortExtension         var observableCollection   new ObservableCollection lt int gt         var maxValue   10          Populate the list in reverse mode  maxValue  maxValue-1       1  0      for  int i   maxValue  i  gt   0  i--                observableCollection Add i                 Assert the collection is in reverse mode     for  int i   maxValue  i  gt   0  i--                Assert AreEqual i  observableCollection maxValue - i                  Sort the observable collection     observableCollection Sort  a  b    gt    return a CompareTo b               Assert elements have been sorted     for  int i   0  i  lt  maxValue  i                  Assert AreEqual i  observableCollection i              Notes  This is just a proof of concept  showing how to sort an ObservableCollection lt  gt  without breaking the bindings on items The sort algorithm has room for improvements and validations  like index checking as pointed out here

User · Answer

lt summary gt      Sorts the collection       lt  summary gt       lt typeparam name  T  gt The type of the elements of the collection  lt  typeparam gt       lt param name  collection  gt The collection to sort  lt  param gt       lt param name  comparison  gt The comparison used for sorting  lt  param gt  public static void Sort lt T gt  this ObservableCollection lt T gt  collection  Comparison lt T gt  comparison   null        var sortableList   new List lt T gt  collection       if  comparison    null          sortableList Sort        else         sortableList Sort comparison        for  var i   0  i  lt  sortableList Count  i                  var oldIndex   collection IndexOf sortableList i            var newIndex   i          if  oldIndex    newIndex              collection Move oldIndex  newIndex             This solution is based on Marco s answer  I had some problems with his solution and therefore improved it by only calling Move if the index actually changed  This should improve performance and also fix the linked issue

User · Answer

animals OrderByDescending a   gt  a  lt what is here   gt      If animals would be a list of object Animal  you could use a property to order the list   public class Animal       public int ID  get  set       public string Name  get  set              ObservableCollection lt Animal gt  animals       animals   animals OrderByDescending a   gt  a Name

User · Answer

Introduction  Basically  if there is a need to display a sorted collection  please consider using the CollectionViewSource class  assign   bind   its Source property to the source collection     an instance of the ObservableCollection lt T gt  class   The idea is that CollectionViewSource class provides an instance of the CollectionView class  This is kind of  projection  of the original  source  collection  but with applied sorting  filtering  etc   References    How to  Sort and Group Data Using a View in XAML  WPF   s CollectionViewSource    Live Shaping  WPF 4 5 introduces  Live Shaping  feature for CollectionViewSource   References    WPF 4 5 New Feature  Live Shaping  CollectionViewSource IsLiveSorting Property  Repositioning data as the data s values change  Live shaping     Solution  If there still a need to sort an instance of the ObservableCollection lt T gt  class  here is how it can be done  The ObservableCollection lt T gt  class itself does not have sort method  But  the collection could be re-created to have items sorted      Animals property setter must raise  property changed  event to notify binding clients     See INotifyPropertyChanged interface for details  Animals   new ObservableCollection lt string gt                 Cat    Dog    Bear    Lion    Mouse            Horse    Rat    Elephant    Kangaroo            Lizard    Snake    Frog    Fish            Butterfly    Human    Cow    Bumble Bee             Animals   new ObservableCollection lt string gt  Animals OrderBy i   gt  i      Additional details  Please note that OrderBy   and OrderByDescending   methods  as other LINQ   extension methods  do not modify the source collection  They instead create a new sequence  i e  a new instance of the class that implements IEnumerable lt T gt  interface   Thus  it is necessary to re-create the collection

User · Answer

I created an extension method to the ObservableCollection  public static void MySort lt TSource TKey gt  this ObservableCollection lt TSource gt  observableCollection  Func lt TSource  TKey gt  keySelector                var a   observableCollection OrderBy keySelector  ToList            observableCollection Clear            foreach var b in a                        observableCollection Add b                     It seems to work and you don t need to implement IComparable

User · Answer

This extension method eliminates the need to sort the entire list   Instead  it inserts each new item in place  So the list is always remains sorted   It turns out that this method just works when a lot of the other methods fail due to missing notifications when the collection changes  And it is rather fast   The code below should be bulletproof  it has been extensively tested in a large-scale production environment   To use      Call on dispatcher  ObservableCollection lt MyClass gt  collectionView   new ObservableCollection lt MyClass gt     var p1   new MyClass     Key    A    var p2   new MyClass     Key    Z    var p3   new MyClass     Key    D    collectionView InsertInPlace p1  o   gt  o Key   collectionView InsertInPlace p2  o   gt  o Key   collectionView InsertInPlace p3  o   gt  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    And the extension method        lt summary gt      Inserts an item into a list in the correct place  based on the provided key and key comparer  Use like OrderBy o   gt  o PropertyWithKey        lt  summary gt  public static void InsertInPlace lt TItem  TKey gt  this ObservableCollection lt TItem gt  collection  TItem itemToAdd  Func lt TItem  TKey gt  keyGetter        int index   collection ToList   BinarySearch keyGetter itemToAdd   Comparer lt TKey gt  Default  keyGetter       collection Insert index  itemToAdd       And the binary search extension method        lt summary gt      Binary search       lt  summary gt       lt returns gt Index of item in collection  lt  returns gt        lt notes gt 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  lt  notes gt  public static int BinarySearch lt TItem  TKey gt  this IList lt TItem gt  collection  TKey keyToFind  IComparer lt TKey gt  comparer  Func lt TItem  TKey gt  keyGetter        if  collection    null                throw new ArgumentNullException nameof collection               int lower   0      int upper   collection Count - 1       while  lower  lt   upper                int middle   lower    upper - lower    2          int comparisonResult   comparer Compare keyToFind  keyGetter Invoke collection middle             if  comparisonResult    0                        return middle                    else if  comparisonResult  lt  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

User · Answer

If performance is your main concern and you dont mind listening to different events  then this is the way to go for a stable sort  public static void Sort lt T gt  this ObservableCollection lt T gt  list  where T   IComparable lt T gt        int i   0      foreach  var item in list OrderBy x   gt  x                 if   item Equals list i                          list i    item                     i             I am not sure if there is anything simpler and faster  at least theoretically   as far as stable sorts go  Doing a ToArray on the ordered list might make the enumeration faster but at worse space complexity  You could also do away with the Equals check to go even faster  but I guess reducing change notification is a welcome thing  Also this doesn t break any bindings  Mind you this raises a bunch of Replace events rather than Move  which is more expected for a Sort operation   and also the number of events raised will be most likely more when compared to other Move approaches in this thread but it is unlikely it matters for performance  I think   Most UI elements must have implemented IList and doing a replace on ILists should be faster than Moves  But more changed events means more screen refreshes  You will have to test it out to see the implications   For a Move answer  see this  Haven t seen a more correct implementation that works even when you have duplicates in the collection

[c#] Sort ObservableCollection<string> through C#

Examples related to c#

Examples related to sorting

Examples related to observablecollection