Comment trier une collection observable ?

Question

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
}

que j'ai placé 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 trier par clé ?

Answer 1

Cette simple extension a parfaitement fonctionné pour moi. Je devais juste m'assurer que MyObject était IComparable . Lorsque la méthode de tri est appelée sur la collection observable de MyObjects , le CompareTo méthode sur MyObject qui appelle ma méthode de tri logique. Bien qu'elle n'ait pas toutes les caractéristiques des autres 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();

Answer 2

J'ai trouvé un article de blog pertinent qui fournit une meilleure réponse que celles données ici :

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

MISE À JOUR

En ObservableSortedList que @romkyns signale dans les commentaires maintient automatiquement l'ordre de tri.

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

Toutefois, il convient également de noter la remarque suivante

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

Answer 3

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 faire le tri comme suit :

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

Answer 4

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 grandes collections, attention au nombre de notifications de changement de collection.

J'ai mis à jour mon code pour améliorer les performances (grâce à nawfal) et pour gérer les doublons, ce qu'aucune autre réponse ne fait au moment où j'écris ces lignes. L'observable est partitionné en une moitié gauche triée et une moitié droite non triée, où à chaque fois l'élément minimum (tel que trouvé dans la liste triée) est déplacé à la fin de la partition triée à partir de la partition non triée. Dans le pire des 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
            }

l'utilisation : Exemple avec un observateur (utilisation d'une classe Personne 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 Personne implémente à la fois IComparable et IEquatable, ce dernier étant utilisé pour minimiser les changements apportés à la collection afin de réduire le nombre de notifications de changement.

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

Pour renvoyer une ObservableCollection, appelez .ToObservableCollection sur *sortedOC* en utilisant par exemple [this implementation][1].

**** orig réponse - 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;
    }
}

Answer 5

J'ai bien aimé l'approche de la méthode d'extension du tri par bulles sur le blog de "Richie" ci-dessus, mais je ne veux pas nécessairement trier en comparant l'objet entier. Je veux plus souvent trier sur une propriété spécifique de l'objet. J'ai donc modifié la méthode pour qu'elle accepte un sélecteur de clé, comme le fait OrderBy, afin que vous puissiez choisir la 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);
                }
            }
        }
    }

que vous appellerez de la même manière que OrderBy, sauf qu'elle 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);