WPF Control Factory

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;

namespace Pfz.Collections
{
	/// <summary>
	/// Read-only wrapper for dictionaries.
	/// </summary>
	[Serializable]
	public sealed class ReadOnlyDictionary<TKey, TValue>:
		IDictionary<TKey, TValue>
	{
		private IDictionary<TKey, TValue> fDictionary;
		
		#region Constructor
			/// <summary>
			/// Creates a new read-only dictionary over an already existing
			/// modifiable dictionary.
			/// </summary>
			public ReadOnlyDictionary(IDictionary<TKey, TValue> modifiableDictionary)
			{
				if (modifiableDictionary == null)
					throw new ArgumentNullException("modifiableDictionary");
			
				if (modifiableDictionary is ReadOnlyDictionary<TKey, TValue>)
					throw new ArgumentException("Do not create a ReadOnlyDictionary of a ReadOnlyDictionary.");
				
				fDictionary = modifiableDictionary;
			}
		#endregion
	
		#region Properties
			#region Keys
				/// <summary>
				/// Gets the keys of the items in this dictionary.
				/// </summary>
				public ICollection<TKey> Keys
				{
					get
					{
						return fDictionary.Keys;
					}
				}
			#endregion
			#region Values
				/// <summary>
				/// Gets the values in this dictionary.
				/// </summary>
				public ICollection<TValue> Values
				{
					get
					{
						return fDictionary.Values;
					}
				}
			#endregion
			#region Count
				/// <summary>
				/// Gets the number of items in this dictionary.
				/// </summary>
				public int Count
				{
					get
					{
						return fDictionary.Count;
					}
				}
			#endregion
			#region this[]
				/// <summary>
				/// Gets a value by it's key.
				/// Throws an exception if the key does not exist.
				/// </summary>
				public TValue this[TKey key]
				{
					get
					{
						return fDictionary[key];
					}
				}
			#endregion
		#endregion
		#region Methods
			#region ContainsKey
				/// <summary>
				/// Returns true if this dictionary contains the given key.
				/// </summary>
				public bool ContainsKey(TKey key)
				{
					return fDictionary.ContainsKey(key);
				}
			#endregion
			#region TryGetValue
				/// <summary>
				/// Tries to get the value for the given key.
				/// If there is no item with the given key, returns null.
				/// </summary>
				public bool TryGetValue(TKey key, out TValue value)
				{
					return fDictionary.TryGetValue(key, out value);
				}
			#endregion
			#region CopyTo
				/// <summary>
				/// Copies the key/value pairs to an array.
				/// </summary>
				public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
				{
					fDictionary.CopyTo(array, arrayIndex);
				}
			#endregion
			#region Contains
				/// <summary>
				/// Verifies if the given pair exists in the dictionary.
				/// </summary>
				public bool Contains(KeyValuePair<TKey, TValue> item)
				{
					return fDictionary.Contains(item);
				}
			#endregion
			#region GetEnumerator
				/// <summary>
				/// Gets an enumerator over all the key/value pairs in this
				/// dictionary.
				/// </summary>
				public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
				{
					return fDictionary.GetEnumerator();
				}
			#endregion
		#endregion

		#region IDictionary<TKey,TValue> Members
			TValue IDictionary<TKey, TValue>.this[TKey key]
			{
				get
				{
					return fDictionary[key];
				}
				set
				{
					throw new ReadOnlyException();
				}
			}

			void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
			{
				throw new ReadOnlyException();
			}
			bool IDictionary<TKey, TValue>.Remove(TKey key)
			{
				throw new ReadOnlyException();
			}
		#endregion
		#region ICollection<KeyValuePair<TKey,TValue>> Members
			void ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey, TValue> item)
			{
				throw new ReadOnlyException();
			}
			void ICollection<KeyValuePair<TKey,TValue>>.Clear()
			{
				throw new ReadOnlyException();
			}
			bool ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly
			{
				get
				{
					return true;
				}
			}
			bool ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey, TValue> item)
			{
				throw new ReadOnlyException();
			}
		#endregion
		#region IEnumerable Members
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		#endregion
	}
}