Threadsafe ObservableCollection

When you are developing applications for WPF, Silverlight or WindowsPhone you often use ObservableCollection<T> to bind your data to the user interface. The limitation of ObservableCollection<T> is that it will only allow updates from the dispatcher thread. So if you want to insert data into the observable collection from another thread you need to write boiler plate code to marshal the changes back on the UI thread via the dispatcher. I wrote an observable collection which solves this issue internally.

Update: Switched from BeginInvoke to Invoke

    [DebuggerDisplay("Count = {Count}")]
    [ComVisible(false)]
    public class SafeObservableCollection : ObservableCollection
    {
        private readonly Dispatcher dispatcher;

        public SafeObservableCollection()
            : this(Enumerable.Empty())
        {
        }

        public SafeObservableCollection(Dispatcher dispatcher)
            : this(Enumerable.Empty(), dispatcher)
        {
        }

        public SafeObservableCollection(IEnumerable collection)
            : this(collection, Dispatcher.CurrentDispatcher)
        {
        }

        public SafeObservableCollection(IEnumerable collection, Dispatcher dispatcher)
        {
            this.dispatcher = dispatcher;

            foreach (T item in collection)
            {
                this.Add(item);
            }
        }

        protected override void SetItem(int index, T item)
        {
            this.ExecuteOrInvoke(() => this.SetItemBase(index, item));
        }

        protected override void MoveItem(int oldIndex, int newIndex)
        {
            this.ExecuteOrInvoke(() => this.MoveItemBase(oldIndex, newIndex));
        }

        protected override void ClearItems()
        {
            this.ExecuteOrInvoke(this.ClearItemsBase);
        }

        protected override void InsertItem(int index, T item)
        {
            this.ExecuteOrInvoke(() => this.InsertItemBase(index, item));
        }

        protected override void RemoveItem(int index)
        {
            this.ExecuteOrInvoke(() => this.RemoveItemBase(index));
        }

        private void RemoveItemBase(int index)
        {
            base.RemoveItem(index);
        }

        private void InsertItemBase(int index, T item)
        {
            base.InsertItem(index, item);
        }

        private void ClearItemsBase()
        {
            base.ClearItems();
        }

        private void MoveItemBase(int oldIndex, int newIndex)
        {
            base.MoveItem(oldIndex, newIndex);
        }

        private void SetItemBase(int index, T item)
        {
            base.SetItem(index, item);
        }

        private void ExecuteOrInvoke(Action action)
        {
            if (this.dispatcher.CheckAccess())
            {
                action();
            }
            else
            {
                this.dispatcher.Invoke(action);
            }
        }
    }

I used a slight variation of Deans test program to test my implementation. I did multiple runs without having any issues. You can also get the source from github.com here.Happy multi threading!