Fast performing and thread safe observable collection

ObservableCollection can be fast, if it wants to. :-)

The code below is a very good example of a thread safe, faster observable collection and you can extend it further to your wish.

using System.Collections.Specialized;public class FastObservableCollection<T> : ObservableCollection<T>{    private readonly object locker = new object();    /// <summary>    /// This private variable holds the flag to    /// turn on and off the collection changed notification.    /// </summary>    private bool suspendCollectionChangeNotification;    /// <summary>    /// Initializes a new instance of the FastObservableCollection class.    /// </summary>    public FastObservableCollection()        : base()    {        this.suspendCollectionChangeNotification = false;    }    /// <summary>    /// This event is overriden CollectionChanged event of the observable collection.    /// </summary>    public override event NotifyCollectionChangedEventHandler CollectionChanged;    /// <summary>    /// This method adds the given generic list of items    /// as a range into current collection by casting them as type T.    /// It then notifies once after all items are added.    /// </summary>    /// <param name="items">The source collection.</param>    public void AddItems(IList<T> items)    {       lock(locker)       {          this.SuspendCollectionChangeNotification();          foreach (var i in items)          {             InsertItem(Count, i);          }          this.NotifyChanges();       }    }    /// <summary>    /// Raises collection change event.    /// </summary>    public void NotifyChanges()    {        this.ResumeCollectionChangeNotification();        var arg             = new NotifyCollectionChangedEventArgs                  (NotifyCollectionChangedAction.Reset);        this.OnCollectionChanged(arg);    }    /// <summary>    /// This method removes the given generic list of items as a range    /// into current collection by casting them as type T.    /// It then notifies once after all items are removed.    /// </summary>    /// <param name="items">The source collection.</param>    public void RemoveItems(IList<T> items)    {        lock(locker)        {           this.SuspendCollectionChangeNotification();           foreach (var i in items)           {             Remove(i);           }           this.NotifyChanges();        }    }    /// <summary>    /// Resumes collection changed notification.    /// </summary>    public void ResumeCollectionChangeNotification()    {        this.suspendCollectionChangeNotification = false;    }    /// <summary>    /// Suspends collection changed notification.    /// </summary>    public void SuspendCollectionChangeNotification()    {        this.suspendCollectionChangeNotification = true;    }    /// <summary>    /// This collection changed event performs thread safe event raising.    /// </summary>    /// <param name="e">The event argument.</param>    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)    {        // Recommended is to avoid reentry         // in collection changed event while collection        // is getting changed on other thread.        using (BlockReentrancy())        {            if (!this.suspendCollectionChangeNotification)            {                NotifyCollectionChangedEventHandler eventHandler =                       this.CollectionChanged;                if (eventHandler == null)                {                    return;                }                // Walk thru invocation list.                Delegate[] delegates = eventHandler.GetInvocationList();                foreach                (NotifyCollectionChangedEventHandler handler in delegates)                {                    // If the subscriber is a DispatcherObject and different thread.                    DispatcherObject dispatcherObject                         = handler.Target as DispatcherObject;                    if (dispatcherObject != null                           && !dispatcherObject.CheckAccess())                    {                        // Invoke handler in the target dispatcher's thread...                         // asynchronously for better responsiveness.                        dispatcherObject.Dispatcher.BeginInvoke                              (DispatcherPriority.DataBind, handler, this, e);                    }                    else                    {                        // Execute handler as is.                        handler(this, e);                    }                }            }        }    }}

Also ICollectionView that sits above the ObservableCollection is actively aware of the changes and performs filtering, grouping, sorting relatively fast as compared to any other source list.

Again observable collections may not be a perfect answer for faster data updates but they do their job pretty well.

Here is a compilation of some solutions which I made. The idea of collection changed invokation taken from first answer.

Also seems that "Reset" operation should be synchronous with main thread otherwise strange things happen to CollectionView and CollectionViewSource.

I think that's because on "Reset" handler tries to read the collection contents immediately and they should be already in place. If you do "Reset" async and than immediately add some items also async than newly added items might be added twice.

public interface IObservableList<T> : IList<T>, INotifyCollectionChanged{}public class ObservableList<T> : IObservableList<T>{    private IList<T> collection = new List<T>();    public event NotifyCollectionChangedEventHandler CollectionChanged;    private ReaderWriterLock sync = new ReaderWriterLock();    protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs args)    {        if (CollectionChanged == null)            return;        foreach (NotifyCollectionChangedEventHandler handler in CollectionChanged.GetInvocationList())        {            // If the subscriber is a DispatcherObject and different thread.            var dispatcherObject = handler.Target as DispatcherObject;            if (dispatcherObject != null && !dispatcherObject.CheckAccess())            {                if ( args.Action == NotifyCollectionChangedAction.Reset )                    dispatcherObject.Dispatcher.Invoke                          (DispatcherPriority.DataBind, handler, this, args);                else                    // Invoke handler in the target dispatcher's thread...                     // asynchronously for better responsiveness.                    dispatcherObject.Dispatcher.BeginInvoke                          (DispatcherPriority.DataBind, handler, this, args);            }            else            {                // Execute handler as is.                handler(this, args);            }        }    }    public ObservableList()    {    }    public void Add(T item)    {        sync.AcquireWriterLock(Timeout.Infinite);        try        {            collection.Add(item);            OnCollectionChanged(                    new NotifyCollectionChangedEventArgs(                      NotifyCollectionChangedAction.Add, item));        }        finally        {            sync.ReleaseWriterLock();        }    }    public void Clear()    {        sync.AcquireWriterLock(Timeout.Infinite);        try        {            collection.Clear();            OnCollectionChanged(                    new NotifyCollectionChangedEventArgs(                        NotifyCollectionChangedAction.Reset));        }        finally        {            sync.ReleaseWriterLock();        }    }    public bool Contains(T item)    {        sync.AcquireReaderLock(Timeout.Infinite);        try        {            var result = collection.Contains(item);            return result;        }        finally        {            sync.ReleaseReaderLock();        }    }    public void CopyTo(T[] array, int arrayIndex)    {        sync.AcquireWriterLock(Timeout.Infinite);        try        {            collection.CopyTo(array, arrayIndex);        }        finally        {            sync.ReleaseWriterLock();        }    }    public int Count    {        get        {            sync.AcquireReaderLock(Timeout.Infinite);            try            {                return collection.Count;            }            finally            {                sync.ReleaseReaderLock();            }        }    }    public bool IsReadOnly    {        get { return collection.IsReadOnly; }    }    public bool Remove(T item)    {        sync.AcquireWriterLock(Timeout.Infinite);        try        {            var index = collection.IndexOf(item);            if (index == -1)                return false;            var result = collection.Remove(item);            if (result)                OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item, index));            return result;        }        finally        {            sync.ReleaseWriterLock();        }    }    public IEnumerator<T> GetEnumerator()    {        return collection.GetEnumerator();    }    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()    {        return collection.GetEnumerator();    }    public int IndexOf(T item)    {        sync.AcquireReaderLock(Timeout.Infinite);        try        {            var result = collection.IndexOf(item);            return result;        }        finally        {            sync.ReleaseReaderLock();        }    }    public void Insert(int index, T item)    {        sync.AcquireWriterLock(Timeout.Infinite);        try        {            collection.Insert(index, item);            OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item, index));        }        finally        {            sync.ReleaseWriterLock();        }    }    public void RemoveAt(int index)    {        sync.AcquireWriterLock(Timeout.Infinite);        try        {            if (collection.Count == 0 || collection.Count <= index)                return;            var item = collection[index];            collection.RemoveAt(index);            OnCollectionChanged(                    new NotifyCollectionChangedEventArgs(                       NotifyCollectionChangedAction.Remove, item, index));        }        finally        {            sync.ReleaseWriterLock();        }    }    public T this[int index]    {        get        {            sync.AcquireReaderLock(Timeout.Infinite);            try            {                var result = collection[index];                return result;            }            finally            {                sync.ReleaseReaderLock();            }        }        set        {            sync.AcquireWriterLock(Timeout.Infinite);            try            {                if (collection.Count == 0 || collection.Count <= index)                    return;                var item = collection[index];                collection[index] = value;                OnCollectionChanged(                        new NotifyCollectionChangedEventArgs(                           NotifyCollectionChangedAction.Replace, value, item, index));            }            finally            {                sync.ReleaseWriterLock();            }        }    }}

I can't add comments because I'm not cool enough yet, but sharing this issue I ran into is probably worth posting even though it's not really an answer. I kept getting an "Index was out of range" exception using this FastObservableCollection, because of the BeginInvoke. Apparently changes being notified can be undone before the handler is called, so to fix this I passed the following as the fourth parameter for the BeginInvoke called from the OnCollectionChanged method (as opposed to using the event args one):

dispatcherObject.Dispatcher.BeginInvoke                          (DispatcherPriority.DataBind, handler, this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));

Instead of this:

dispatcherObject.Dispatcher.BeginInvoke                          (DispatcherPriority.DataBind, handler, this, e);

This fixed the "Index was out of range" issue I was running into. Here's a more detailed explaination / code snpipet: Where do I get a thread-safe CollectionView?