Comment trier une collection observable?

J'ai une classe suivante:

[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
}

Ce que j'ai mis dans une 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"));

Q: Comment puis-je le trier par clé?

Le tri d'un observable et le retour du même objet trié peuvent être effectués à l'aide d'une méthode d'extension. Pour les collections plus importantes, faites attention au nombre de notifications de modification de collection.

J'ai mis à jour mon code pour améliorer les performances et gérer les doublons (merci à nawfal pour avoir mis en évidence les mauvaises performances de l'original même si cela a bien fonctionné sur l'exemple de données d'origine). L'observable est partitionné en une moitié triée à gauche et une moitié droite non triée, où chaque fois que l'élément minimum (tel qu'il se trouve dans la liste triée) est déplacé à la fin de la partition triée à partir de l'élément non trié. Pire cas O (n). Essentiellement un tri par sélection (voir ci-dessous pour la sortie).

public static void Sort<T>(this ObservableCollection<T> collection)
        where T : IComparable<T>, IEquatable<T>
    {
        List<T> sorted = collection.OrderBy(x => x).ToList();

        int ptr = 0;
        while (ptr < 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<T>(ObservableCollection<T> collection, int startIndex, T other)
            {
                for (int i = startIndex; i < collection.Count; i++)
                {
                    if (other.Equals(collection[i]))
                        return i;
                }
    
                return -1; // decide how to handle error case
            }

utilisation: Exemple avec un observateur (utilisé une classe Person pour rester simple)

    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 = "Alice", Age = 39},
                    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 = 5},
                    new Person {Name = "Kim", Age = 19}
                };
    
                //what do observers see?
            
    
observable.CollectionChanged += (sender, e) =>
        {
            Console.WriteLine(
                e.OldItems[0] + " move from " + e.OldStartingIndex + " to " + e.NewStartingIndex);
            int i = 0;
            foreach (var person in sender as ObservableCollection<Person>)
            {
                if (i == e.NewStartingIndex)
                {
                    Console.Write("(" + (person as Person).Age + "),");
                }
                else
                {
                    Console.Write((person as Person).Age + ",");
                }
                
                i++;
            }

            Console.WriteLine();
        };

Détails de la progression du tri montrant comment la collection est pivotée:

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,

La classe Person implémente à la fois IComparable et IEquatable, ce dernier est utilisé pour minimiser les modifications apportées à la collection afin de réduire le nombre de notifications de modification déclenchées

• EDIT Trie la même collection sans créer une nouvelle copie *

Pour renvoyer un ObservableCollection, appelez .ToObservableCollection sur * sortedOC * en utilisant par exemple [cette implémentation] [1].

**** réponse orig - cela crée une nouvelle collection **** Vous pouvez utiliser linq comme l'illustre la méthode doSort ci-dessous. Un extrait de code rapide: produit

3: xey 6: fty 7: aaa

Vous pouvez également utiliser une méthode d'extension sur la collection elle-même

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;
    }
}

Cette simple extension a parfaitement fonctionné pour moi. Je devais juste m'assurer que MyObjectc'était le cas IComparable. Lorsque la méthode de tri est appelée sur la collection observable de MyObjects, la CompareTométhode sur MyObjectest appelée, qui appelle ma méthode de tri logique. Bien qu'il n'ait pas toutes les cloches et les sifflets du reste des réponses affichées ici, c'est exactement ce dont j'avais besoin.

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();

J'ai trouvé une entrée de blog pertinente qui fournit une meilleure réponse que celles ici:

http://kiwigis.blogspot.com/2010/03/how-to-sort-obversablecollection.html

METTRE À JOUR

L' ObservableSortedList que @romkyns souligne dans les commentaires maintient automatiquement l'ordre de tri.

Implémente une collection observable qui maintient ses éléments dans un ordre trié. En particulier, les modifications des propriétés d'élément qui entraînent des modifications d'ordre sont gérées correctement.

Notez cependant aussi la remarque

Peut être bogué en raison de la complexité relative de l'interface impliquée et de sa documentation relativement pauvre (voir https://stackoverflow.com/a/5883947/33080 ).

Vous pouvez utiliser cette méthode simple:

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);
}

Vous pouvez trier comme ceci:

_collection.Sort(i => i.Key);

Plus de détails: http://jaider.net/2011-05-04/sort-a-observablecollection/

WPF fournit un tri en direct prêt à l' emploi à l'aide de la ListCollectionViewclasse ...

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);
    }
}

Une fois cette initialisation terminée, il n'y a plus rien à faire. L'avantage par rapport à un tri passif est que ListCollectionView fait tout le gros du travail d'une manière transparente pour le développeur. Les nouveaux éléments sont automatiquement placés dans leur ordre de tri correct. Toute classe qui dérive deIComparer de T convient à la propriété de tri personnalisée.

Consultez ListCollectionView pour la documentation et les autres fonctionnalités.

J'ai aimé l'approche de la méthode d'extension de tri à bulles sur le blog de "Richie" ci-dessus, mais je ne veux pas nécessairement simplement trier en comparant l'objet entier. Je souhaite plus souvent trier sur une propriété spécifique de l'objet. Je l'ai donc modifié pour accepter un sélecteur de clé comme le fait OrderBy afin que vous puissiez choisir sur quelle propriété trier:

    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);
                }
            }
        }
    }

Ce que vous appelleriez de la même manière que vous appelleriez OrderBy, sauf qu'il triera l'instance existante de votre ObservableCollection au lieu de renvoyer une nouvelle collection:

ObservableCollection<Person> people = new ObservableCollection<Person>();
...

people.Sort(p => p.FirstName);

La réponse de @ NielW est la voie à suivre, pour un véritable tri sur place. Je voulais ajouter une solution légèrement modifiée qui vous permet de contourner l'utilisation 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);
    }
}

maintenant, vous pouvez l'appeler comme la plupart des méthodes LINQ:

myObservableCollection.Sort(o => o.MyProperty);

Je voudrais ajouter à la réponse de NeilW . Pour incorporer une méthode qui ressemble au orderby. Ajoutez cette méthode en tant qu'extension:

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);
}

Et utilisez comme:

myCollection = new ObservableCollection<MyObject>();

//Sorts in place, on a specific Func<T,T>
myCollection.Sort(x => x.ID);

Une variante est l'endroit où vous triez la collection sur place à l'aide d'un algorithme de tri par sélection . Les éléments sont mis en place à l'aide de la Moveméthode. Chaque mouvement déclenchera l' CollectionChangedévénement avec NotifyCollectionChangedAction.Move(et aussi PropertyChangedavec le nom de la propriété Item[]).

Cet algorithme a quelques propriétés intéressantes:

• L'algorithme peut être implémenté comme un tri stable.
• Le nombre d'éléments déplacés dans la collection (par exemple les CollectionChangedévénements déclenchés) est presque toujours inférieur à celui d'autres algorithmes similaires comme le tri par insertion et le tri par bulles.

L'algorithme est assez simple. La collection est itérée pour trouver le plus petit élément qui est ensuite déplacé au début de la collection. Le processus est répété à partir du deuxième élément et ainsi de suite jusqu'à ce que tous les éléments aient été mis en place. L'algorithme n'est pas très efficace, mais pour tout ce que vous allez afficher dans une interface utilisateur, cela ne devrait pas avoir d'importance. Cependant, en termes de nombre d'opérations de déménagement, c'est assez efficace.

Voici une méthode d'extension qui, pour simplifier, nécessite que les éléments implémentent IComparable<T> . D'autres options utilisent un IComparer<T>ou un 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);
    }
  }

}

Le tri d'une collection consiste simplement à appeler la méthode d'extension:

var collection = new ObservableCollection<String>(...);
collection.Sort();

Pour améliorer un peu la méthode d'extension sur la réponse xr280xr, j'ai ajouté un paramètre booléen facultatif pour déterminer si le tri est descendant ou non. J'ai également inclus la suggestion de Carlos P dans le commentaire de cette réponse. Veuillez voir ci-dessous.

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);
            }
        }
    }

Avez-vous besoin de garder votre collection triée à tout moment? Lorsque vous récupérez les paires, avez-vous besoin qu'elles soient toujours triées, ou ce n'est que pour quelques fois (peut-être juste pour la présentation)? Quelle sera la taille de votre collection? De nombreux facteurs peuvent vous aider à décider de la méthode à utiliser.

Si vous avez besoin que la collection soit triée à tout moment, même lorsque vous insérez ou supprimez des éléments et que la vitesse d'insertion n'est pas un problème, vous devriez peut-être implémenter une sorte de SortedObservableCollection @Gerrie Schenck mentionné ou vérifier cette implémentation .

Si vous avez besoin que votre collection soit triée quelques fois, utilisez:

my_collection.OrderBy(p => p.Key);

Cela prendra du temps pour trier la collection, mais même dans ce cas, cela pourrait être la meilleure solution en fonction de ce que vous en faites.

Ma réponse actuelle est déjà celle qui a le plus de voix, mais j'ai trouvé une manière meilleure et plus moderne de le faire.

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)))));

Créez une nouvelle classe SortedObservableCollection, dérivez-la ObservableCollectionet implémentez-la IComparable<Pair<ushort, string>>.

Une façon serait de le convertir en une liste, puis d'appeler Sort (), en fournissant un délégué de comparaison. Quelque chose comme:-

(non testé)

my_collection.ToList().Sort((left, right) => left == right ? 0 : (left > right ? -1 : 1));

Je pense que c'est la solution la plus élégante:

http://www.xamlplayground.org/post/2009/07/18/Use-CollectionViewSource-effectively-in-MVVM-applications.aspx

Que diable, je vais également ajouter une réponse rapidement bricolée ... cela ressemble un peu à d'autres implémentations ici, mais je l'ajouterai quand même:

(à peine testé, j'espère que je ne me gêne pas)

Décrivons d'abord quelques objectifs (mes hypothèses):

1) Doit trier ObservableCollection<T>en place, pour maintenir les notifications, etc.

2) Ne doit pas être horriblement inefficace (c'est-à-dire quelque chose de proche de la "bonne" efficacité de tri standard)

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
    }
}

Aucune de ces réponses n'a fonctionné dans mon cas. Soit parce qu'il fout la liaison, ou nécessite tellement de codage supplémentaire que c'est une sorte de cauchemar, soit la réponse est tout simplement cassée. Alors, voici une autre réponse plus simple que j'ai pensé. C'est beaucoup moins de code et cela reste la même collection observable avec un type de méthode this.sort supplémentaire. Faites-moi savoir s'il y a une raison pour laquelle je ne devrais pas le faire de cette façon (efficacité, etc.)?

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);
            }
      }
}

... Où ScoutItem est ma classe publique. Cela semblait juste beaucoup plus simple. Avantage supplémentaire: cela fonctionne réellement et ne gâche pas les liaisons ou ne renvoie pas une nouvelle collection, etc.

D'accord, comme j'avais des problèmes pour faire fonctionner ObservableSortedList avec XAML, j'ai continué et j'ai créé SortingObservableCollection . Il hérite d'ObservableCollection, il fonctionne donc avec XAML et je l'ai testé à une couverture de code de 98%. Je l'ai utilisé dans mes propres applications, mais je ne promets pas qu'il soit sans bogue. N'hésitez pas à contribuer. Voici un exemple d'utilisation de code:

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

C'est un PCL, il devrait donc fonctionner avec Windows Store, Windows Phone et .NET 4.5.1.

C'est ce que je fais avec les extensions 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);
        }
    }

Cela a fonctionné pour moi, je l'ai trouvé il y a longtemps quelque part.

// 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));
            }
        }
    }

Usage:

MySortableCollection.Sort(x => x, System.ComponentModel.ListSortDirection.Ascending);

J'avais besoin de pouvoir trier par plusieurs choses et non pas une seule. Cette réponse est basée sur certaines des autres réponses, mais elle permet un tri plus complexe.

static class Extensions
{
    public static void Sort<T, TKey>(this ObservableCollection<T> collection, Func<ObservableCollection<T>, TKey> sort)
    {
        var sorted = (sort.Invoke(collection) as IOrderedEnumerable<T>).ToArray();
        for (int i = 0; i < sorted.Count(); i++)
            collection.Move(collection.IndexOf(sorted[i]), i);
    }
}

Lorsque vous l'utilisez, passez une série d'appels OrderBy / ThenBy. Comme ça:

Children.Sort(col => col.OrderByDescending(xx => xx.ItemType == "drive")
                    .ThenByDescending(xx => xx.ItemType == "folder")
                    .ThenBy(xx => xx.Path));

J'ai beaucoup appris des autres solutions, mais j'ai trouvé quelques problèmes. Premièrement, certains dépendent d'IndexOf qui a tendance à être assez lent pour les grandes listes. Deuxièmement, mon ObservableCollection avait des entités EF et l'utilisation de Remove semblait corrompre certaines des propriétés de clé étrangère. Peut-être que je fais quelque chose de mal.

Quoi qu'il en soit, A Move peut être utilisé à la place Supprimer / Insérer, mais cela pose certains problèmes avec le correctif de performances.

Pour résoudre le problème de performances, je crée un dictionnaire avec les valeurs triées IndexOf. Pour maintenir le dictionnaire à jour et conserver les propriétés de l'entité, utilisez un swap implémenté avec deux mouvements au lieu d'un tel qu'implémenté dans d'autres solutions.

Un seul déplacement déplace les index des éléments entre les emplacements, ce qui invaliderait le dictionnaire IndexOf. L'ajout d'un second mouvement pour implémenter un échange restaure les emplacements.

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++;
        }
}

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));