Como classifico uma coleção observável?

Eu tenho uma aula a seguir:

[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 coloquei em um 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"));

P: Como faço para classificar por chave?

Classificar um observável e retornar o mesmo objeto classificado pode ser feito usando um método de extensão. Para coleções maiores, esteja atento ao número de notificações alteradas na coleção.

Eu atualizei meu código para melhorar o desempenho e lidar com duplicatas (obrigado a nawfal por destacar o desempenho ruim do original, embora tenha funcionado bem no exemplo de dados original). O observável é particionado em uma metade classificada à esquerda e uma metade não classificada à direita, onde cada vez que o item mínimo (conforme encontrado na lista classificada) é deslocado para o final da partição classificada a partir do não classificado. Pior caso O (n). Essencialmente, uma classificação de seleção (veja a saída abaixo).

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
            }

uso: amostra com um observador (usei uma classe Person para mantê-lo simples)

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

Detalhes do andamento da classificação, mostrando como a coleção é dinamizada:

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,

A classe Person implementa IComparable e IEquatable; o último é usado para minimizar as mudanças na coleção de modo a reduzir o número de notificações de mudança levantadas

• EDIT Classifica a mesma coleção sem criar uma nova cópia *

Para retornar um ObservableCollection, chame .ToObservableCollection em * SortOC * usando, por exemplo, [esta implementação] [1].

**** resposta original - isso cria uma nova coleção **** Você pode usar linq como o método doSort abaixo ilustra. Um rápido snippet de código: produz

3: xey 6: fty 7: aaa

Alternativamente, você pode usar um método de extensão na própria coleção

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

Esta extensão simples funcionou perfeitamente para mim. Eu só tinha que ter certeza de que MyObjectera IComparable. Quando o método de classificação é chamado na coleção observável de MyObjects, oCompareTo método em MyObjecté chamado, o que chama meu método de classificação lógica. Embora não tenha todos os sinos e assobios do resto das respostas postadas aqui, é exatamente o que eu precisava.

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

Encontrei uma entrada de blog relevante que fornece uma resposta melhor do que as aqui:

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

ATUALIZAR

O ObservableSortedList que @romkyns aponta nos comentários mantém a ordem de classificação automaticamente.

Implementa uma coleção observável que mantém seus itens em ordem de classificação. Em particular, as alterações nas propriedades do item que resultam em alterações na ordem são tratadas corretamente.

No entanto, observe também a observação

Pode haver bugs devido à complexidade comparativa da interface envolvida e sua documentação relativamente pobre (consulte https://stackoverflow.com/a/5883947/33080 ).

Você pode usar este método simples:

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

Você pode classificar assim:

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

Mais detalhes: http://jaider.net/2011-05-04/sort-a-observablecollection/

O WPF fornece classificação ao vivo pronta para uso usando a 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);
    }
}

Depois que a inicialização for concluída, não há mais nada a fazer. A vantagem sobre a classificação passiva é que ListCollectionView faz todo o trabalho pesado de uma forma transparente para o desenvolvedor. Novos itens são colocados automaticamente em sua ordem de classificação correta. Qualquer classe que derive IComparerde T é adequada para a propriedade de classificação personalizada.

Consulte ListCollectionView para obter a documentação e outros recursos.

Eu gostei da abordagem do método de extensão de classificação por bolha no blog de "Richie" acima, mas não quero necessariamente apenas classificar comparando o objeto inteiro. Com mais frequência, desejo classificar por uma propriedade específica do objeto. Então, eu o modifiquei para aceitar um seletor de chave da maneira que OrderBy faz, para que você possa escolher em qual propriedade classificar:

    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 você chamaria da mesma maneira que chamaria OrderBy, exceto que classificará a instância existente de sua ObservableCollection em vez de retornar uma nova coleção:

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

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

A resposta de @NielW é o caminho a percorrer, para uma classificação real no local. Eu queria adicionar uma solução ligeiramente alterada que permite que você ignore a necessidade de usar 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);
    }
}

agora você pode chamá-lo como qualquer método LINQ:

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

Eu gostaria de acrescentar à resposta de NeilW . Para incorporar um método que se assemelha ao encarregado do serviço. Adicione este método como uma extensão:

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

E use como:

myCollection = new ObservableCollection<MyObject>();

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

Uma variação é quando você classifica a coleção no local usando um algoritmo de classificação de seleção . Os elementos são movidos para o lugar usando o Movemétodo. Cada movimento irá disparar o CollectionChangedevento com NotifyCollectionChangedAction.Move(e também PropertyChangedcom o nome da propriedadeItem[] ).

Este algoritmo tem algumas propriedades interessantes:

• O algoritmo pode ser implementado como uma classificação estável.
• O número de itens movidos na coleção (por exemplo, CollectionChangedeventos disparados) é quase sempre menor do que outros algoritmos semelhantes, como classificação por inserção e classificação por bolha.

O algoritmo é bastante simples. A coleção é iterada para encontrar o menor elemento que é movido para o início da coleção. O processo é repetido começando no segundo elemento e assim por diante até que todos os elementos tenham sido movidos para o lugar. O algoritmo não é terrivelmente eficiente, mas para qualquer coisa que você vá exibir em uma interface de usuário, isso não importa. No entanto, em termos de número de operações de movimentação, é bastante eficiente.

Aqui está um método de extensão que, para simplificar, requer que os elementos sejam implementados IComparable<T>. Outras opções estão usando um IComparer<T>ou umFunc<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);
    }
  }

}

Classificar uma coleção é simplesmente uma questão de invocar o método de extensão:

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

Para melhorar um pouco o método de extensão na resposta xr280xr, adicionei um parâmetro bool opcional para determinar se a classificação é decrescente ou não. Também incluí a sugestão do Carlos P no comentário a essa resposta. Por favor veja abaixo.

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

Você precisa manter sua coleção organizada o tempo todo? Ao recuperar os pares, você precisa que eles estejam sempre classificados ou é apenas por algumas vezes (talvez apenas para apresentação)? Quão grande você espera que sua coleção seja? Existem muitos fatores que podem ajudá-lo a decidir o método de bruxa a ser usado.

Se você precisa que a coleção seja classificada o tempo todo, mesmo quando você insere ou deleta elementos e a velocidade de inserção não é um problema, talvez você deva implementar algum tipo de SortedObservableCollectioncomo @Gerrie Schenck mencionou ou verificar esta implementação .

Se você precisa que sua coleção seja classificada apenas algumas vezes, use:

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

Isso levará algum tempo para classificar a coleção, mas mesmo assim, pode ser a melhor solução dependendo do que você está fazendo com ela.

Minha resposta atual já tem mais votos, mas encontrei uma maneira melhor e mais moderna de fazer isso.

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

Faça uma nova classe SortedObservableCollection, derive-a ObservableCollectione implemente-a IComparable<Pair<ushort, string>>.

Uma maneira seria convertê-lo em uma lista e, em seguida, chamar Sort (), fornecendo um delegado de comparação. Algo como:-

(não testado)

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

Eu acho que esta é a solução mais elegante:

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

Que diabos, vou dar uma resposta rapidamente remendada também ... parece um pouco com algumas outras implementações aqui, mas vou adicioná-la a qualquer um:

(mal testei, espero não estar me envergonhando)

Vamos estabelecer alguns objetivos primeiro (minhas suposições):

1) Deve classificar ObservableCollection<T> no local, para manter notificações, etc.

2) Não deve ser terrivelmente ineficiente (ou seja, algo próximo da eficiência de classificação "boa" padrão)

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

Nenhuma dessas respostas funcionou no meu caso. Ou porque atrapalha a ligação ou requer tantos códigos adicionais que é uma espécie de pesadelo, ou a resposta é simplesmente quebrada. Então, aqui está outra resposta mais simples que pensei. É muito menos código e permanece a mesma coleção observável com um tipo de método this.sort adicional. Deixe-me saber se há algum motivo pelo qual eu não deveria estar fazendo isso (eficiência, 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);
            }
      }
}

... Onde ScoutItem é minha classe pública. Parecia muito mais simples. Benefício adicionado: ele realmente funciona e não mexe com ligações ou retorna uma nova coleção, etc.

Certo, como estava tendo problemas para fazer ObservableSortedList funcionar com o XAML, fui em frente e criei SortingObservableCollection . Ele herda de ObservableCollection, por isso funciona com XAML e testei a unidade com 98% de cobertura de código. Eu usei em meus próprios aplicativos, mas não prometo que é livre de bugs. Sinta-se à vontade para contribuir. Aqui está um exemplo de uso de código:

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

É um PCL, portanto, deve funcionar com Windows Store, Windows Phone e .NET 4.5.1.

Isso é o que eu faço com as extensões 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);
        }
    }

Isso funcionou para mim, encontrei há muito tempo em algum lugar.

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

Uso:

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

Eu precisava ser capaz de classificar por várias coisas, não apenas uma. Essa resposta é baseada em algumas das outras respostas, mas permite uma classificação mais complexa.

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

Ao usá-lo, faça uma série de chamadas OrderBy / ThenBy. Como isso:

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

Aprendi muito com as outras soluções, mas encontrei alguns problemas. Primeiro, alguns dependem do IndexOf, que tende a ser muito lento para listas grandes. Em segundo lugar, minha ObservableCollection tinha entidades EF e o uso de Remove parecia corromper algumas das propriedades de chave estrangeira. Talvez eu esteja fazendo algo errado.

Independentemente disso, A Move pode ser usado em vez de Remover / Inserir, mas isso causa alguns problemas com a correção de desempenho.

Para corrigir o problema de desempenho, crio um dicionário com os valores classificados IndexOf. Para manter o dicionário atualizado e preservar as propriedades da entidade, use uma troca implementada com dois movimentos em vez de um conforme implementado em outras soluções.

Um único movimento desloca os índices dos elementos entre os locais, o que invalidaria o dicionário IndexOf. Adicionar um segundo movimento para implementar uma troca restaura os locais.

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