SortableObservableCollection<T>

    public class SortableObservableCollection<T> : ObservableCollection<T>
    {
        public SortableObservableCollection(List<T> list)
            : base(list)
        {
        }

        public SortableObservableCollection(IEnumerable<T> collection)
            : base(collection)
        {
        }

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

    /// <summary>
    /// DESCRIPTION 
    /// </summary>
     public class SortableObservableCollection<T> : ObservableCollection<T>
    {
        private bool sorting;

        public void Sort()
        {
            this.Sort(Comparer<T>.Default);
        }

        public void Sort(IComparer<T> comparer)
        {
            this.sorting = true;

            int i, j;
            for (i = 1; i < this.Count; i++)
            {
                T index = this[i];
                j = i;
                while ((j > 0) && (comparer.Compare(this[j - 1], index) == 1))
                {
                    this[j] = this[j - 1];
                    j = j - 1;
                }
                this[j] = index;
            }

            this.sorting = false;

            this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }

        protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (this.sorting == false)
            {
                base.OnCollectionChanged(e);
            }
        }
    }

    /// <summary>
    /// Create a instance of SortableObservableCollection.
    /// </summary>
    /// <typeparam name="T">Collection</typeparam>
     public class SortableObservableCollection<T> : ObservableCollection<T>
    {
        public virtual void Sort()
        {
            this.Sort(0, Count, null);
        }

        public virtual void Sort(IComparer<T> comparer)
        {
            this.Sort(0, Count, comparer);
        }

        public virtual void Sort(int index, int count, IComparer<T> comparer)
        {
            (this.Items as List<T>).Sort(index, count, comparer);
            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }
    }