Introducing the Model Thread View Thread Pattern

#region File and License Information

/*
<File>
	<Copyright>Copyright © 2009, Daniel Vaughan. All rights reserved.</Copyright>
	<License>
	This file is part of DanielVaughan's base library

    DanielVaughan's base library is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    DanielVaughan's base library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with DanielVaughan's base library.  If not, see http://www.gnu.org/licenses/.
	</License>
	<Owner Name="Daniel Vaughan" Email="dbvaughan@gmail.com"/>
	<CreationDate>2010-04-22 17:26:58Z</CreationDate>
</File>
*/

#endregion

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;

using DanielVaughan.Concurrency;

namespace DanielVaughan.MtvtExample.Collections
{
	/// <summary>
	/// Provides <see cref="INotifyCollectionChanged"/> events on the subscription thread 
	/// using an <see cref="ISynchronizationContext"/>.
	/// </summary>
	/// <typeparam name="T">The type of items in the collection.</typeparam>
	public class SynchronizedObservableCollection<T> : Collection<T>, 
		INotifyCollectionChanged, INotifyPropertyChanged
	{
		bool busy;
		readonly DelegateManager collectionChangedManager;
		readonly ISynchronizationContext uiContext;

		/// <summary>
		/// Occurs when the items list of the collection has changed, 
		/// or the collection is reset.
		/// </summary>
		public event NotifyCollectionChangedEventHandler CollectionChanged
		{
			add
			{
				collectionChangedManager.Add(value);
			}
			remove
			{
				collectionChangedManager.Remove(value);
			}
		}

		PropertyChangedEventHandler propertyChanged;

		/// <summary>
		/// Occurs when a property value changes.
		/// </summary>
		event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
		{
			add
			{
				propertyChanged += value;
			}
			remove
			{
				propertyChanged -= value;
			}
		}

		/// <summary>
		/// Initializes a new instance 
		/// of the <see cref="SynchronizedObservableCollection&lt;T&gt;"/> class.
		/// </summary>
		/// <param name="contextProvider">The synchronization context provider, 
		/// which is used to determine on what thread a handler is invoked.</param>
		public SynchronizedObservableCollection(
			IProvider<ISynchronizationContext> contextProvider = null)
		{
			uiContext = UISynchronizationContext.Instance;
			collectionChangedManager = new DelegateManager(true, contextProvider: contextProvider);
		}

		/// <summary>
		/// Initializes a new instance 
		/// of the <see cref="SynchronizedObservableCollection&lt;T&gt;"/> class.
		/// </summary>
		/// <param name="collection">The collection to copy.</param>
		/// <param name="contextProvider">The synchronization context provider, 
		/// which is used to determine on what thread a handler is invoked.</param>
		public SynchronizedObservableCollection(IEnumerable<T> collection, 
			IProvider<ISynchronizationContext> contextProvider = null) : this(contextProvider)
		{
			ArgumentValidator.AssertNotNull(collection, "collection");
			CopyFrom(collection);
		}

		public SynchronizedObservableCollection(List<T> list, 
			IProvider<ISynchronizationContext> contextProvider = null) 
			: base(list != null ? new List<T>(list.Count) : list)
		{
			uiContext = UISynchronizationContext.Instance;
			collectionChangedManager = new DelegateManager(true, contextProvider: contextProvider);
			CopyFrom(list);
		}

		void PreventReentrancy()
		{
			if (busy)
			{
				throw new InvalidOperationException(
					"Cannot Change SynchronizedObservableCollection");
			}
		}

		protected override void ClearItems()
		{
			uiContext.InvokeAndBlockUntilCompletion(
				delegate
				{
					PreventReentrancy();
					base.ClearItems();
					OnPropertyChanged("Count");
					OnPropertyChanged("Item[]");
					OnCollectionChanged(new NotifyCollectionChangedEventArgs(
						NotifyCollectionChangedAction.Reset));                                  		
				});
		}

		void CopyFrom(IEnumerable<T> collection)
		{
			uiContext.InvokeAndBlockUntilCompletion(
				delegate
				{
					IList<T> items = Items;
					if (collection != null && items != null)
					{
						using (IEnumerator<T> enumerator = collection.GetEnumerator())
						{
							while (enumerator.MoveNext())
							{
								items.Add(enumerator.Current);
							}
						}
					}
				});
		}

		protected override void InsertItem(int index, T item)
		{
			uiContext.InvokeAndBlockUntilCompletion(
				delegate
				{
					base.InsertItem(index, item);
					OnPropertyChanged("Count");
					OnPropertyChanged("Item[]");
					OnCollectionChanged(new NotifyCollectionChangedEventArgs(
						NotifyCollectionChangedAction.Add, item, index));
				});
		}

		protected virtual void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
		{
			busy = true;
			try
			{
				collectionChangedManager.InvokeDelegates(null, e);
			}
			finally
			{
				busy = false;
			}
		}

		protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
		{
			if (propertyChanged != null)
			{
				busy = true;
				try
				{
					propertyChanged(this, e);
				}
				finally
				{
					busy = false;
				}
			}
		}

		void OnPropertyChanged(string propertyName)
		{
			OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
		}
		
		protected override void RemoveItem(int index)
		{
			uiContext.InvokeAndBlockUntilCompletion(
				delegate
				{
					PreventReentrancy();
					T changedItem = base[index];
					base.RemoveItem(index);

					OnPropertyChanged("Count");
					OnPropertyChanged("Item[]");
					OnCollectionChanged(new NotifyCollectionChangedEventArgs(
						NotifyCollectionChangedAction.Remove, changedItem, index));
				});
		}

		protected override void SetItem(int index, T item)
		{
			uiContext.InvokeAndBlockUntilCompletion(
				delegate
				{
					PreventReentrancy();
					T oldItem = base[index];
					base.SetItem(index, item);

					OnPropertyChanged("Item[]");
					OnCollectionChanged(new NotifyCollectionChangedEventArgs(
						NotifyCollectionChangedAction.Replace, item, oldItem, index));
				});
		}
	}
}