WPF Control Factory

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

namespace Pfz.Collections
{
	/// <summary>
	/// Read-only wrapper for hashsets.
	/// </summary>
	[Serializable]
	public sealed class ReadOnlyHashSet<T>:
		ICollection<T>
	{
		private HashSet<T> fHashSet;
		
		/// <summary>
		/// Creates a new read-only hashset wrapper over a modifiable hashset.
		/// </summary>
		public ReadOnlyHashSet(HashSet<T> modifiableHashset)
		{
			if (modifiableHashset == null)
				throw new ArgumentNullException("modifiableHashset");
		
			fHashSet = modifiableHashset;
		}

		/// <summary>
		/// Gets the number of items in this hashset.
		/// </summary>
		public int Count
		{
			get
			{
				return fHashSet.Count;
			}
		}

		/// <summary>
		/// Returns an enumerator to iterate through all items in this
		/// hashset.
		/// </summary>
		public IEnumerator<T> GetEnumerator()
		{
			return fHashSet.GetEnumerator();
		}

		/// <summary>
		/// Returns true if the given item exists in this hashset, otherwise
		/// false.
		/// </summary>
		public bool Contains(T item)
		{
			return fHashSet.Contains(item);
		}
		
		/// <summary>
		/// Copies the values of this hashset to an array.
		/// </summary>
		public void CopyTo(T[] array)
		{
			fHashSet.CopyTo(array);
		}
		
		/// <summary>
		/// Copies the values of this hashset to an array, beginning
		/// at the given destination index.
		/// </summary>
		public void CopyTo(T[] array, int arrayIndex)
		{
			fHashSet.CopyTo(array, arrayIndex);
		}
		
		/// <summary>
		/// Copies the given count items from this hashset to an array,
		/// beginning at the given destination index.
		/// </summary>
		public void CopyTo(T[] array, int arrayIndex, int count)
		{
			fHashSet.CopyTo(array, arrayIndex, count);
		}

		/// <summary>
		/// Determines wheter this hashset is a proper subset of the other
		/// collection.
		/// </summary>
		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			return fHashSet.IsProperSubsetOf(other);
		}
		
		/// <summary>
		/// Determines wheter this hashset is a proper superset of the other
		/// collection.
		/// </summary>
		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			return fHashSet.IsProperSupersetOf(other);
		}
		
		/// <summary>
		/// Determines wheter this hashset is a subset of the other
		/// collection.
		/// </summary>
		public bool IsSubsetOf(IEnumerable<T> other)
		{
			return fHashSet.IsSubsetOf(other);
		}
		
		/// <summary>
		/// Determines wheter this hashset is a superset of the other
		/// collection.
		/// </summary>
		public bool IsSupersetOf(IEnumerable<T> other)
		{
			return fHashSet.IsSupersetOf(other);
		}

		/// <summary>
		/// Determines wheter this hashset overlaps the other collection.
		/// </summary>
		public bool Overlaps(IEnumerable<T> other)
		{
			return fHashSet.Overlaps(other);
		}

		#region ICollection<T> Members
			void ICollection<T>.Add(T item)
			{
				throw new ReadOnlyException();
			}
			void ICollection<T>.Clear()
			{
				throw new ReadOnlyException();
			}
			bool ICollection<T>.IsReadOnly
			{
				get
				{
					return true;
				}
			}
			bool ICollection<T>.Remove(T item)
			{
				throw new ReadOnlyException();
			}
		#endregion
		#region IEnumerable Members
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		#endregion
	}
}