WPF Control Factory

using System;
using System.IO;
using Pfz.Extensions.DisposeExtensions;
using Pfz.Extensions.MonitorLockExtensions;
using Pfz.Threading;

namespace Pfz
{
	/// <summary>
	/// Stream class that has a Dispose receiving an Exception as the cause
	/// of the dispose. Calling any method after the dispose will throw a
	/// new ObjectDisposedException with that exception as the inner exception.
	/// </summary>
	public abstract class ExceptionAwareStream:
		Stream,
		IExceptionAwareDisposable
	{
		/// <summary>
		/// Disposes the stream and sets the DisposeException.
		/// </summary>
		public void Dispose(Exception exception)
		{
			DisposeException = exception;
			Dispose();
		}
		
		/// <summary>
		/// Implemented to guarantee that it will be executed only once.
		/// You must reimplement DoDispose, as this method is sealed.
		/// </summary>
		protected sealed override void Dispose(bool disposing)
		{
			IDisposable lockDisposer = null;
			try
			{
				AbortSafe.Run(() => lockDisposer = DisposeLock.LockWithTimeout());

				if (WasDisposed)
					return;
				
				try
				{
				}
				finally
				{
					WasDisposed = true;
					lockDisposer.Dispose();
					OnDispose(disposing);
				}
			}
			finally
			{
				lockDisposer.CheckedDispose();
			}
		}
		
		/// <summary>
		/// Does the effective dispose.
		/// </summary>
		protected virtual void OnDispose(bool disposing)
		{
			base.Dispose(disposing);
		}

		private object fDisposeLock = new object();
		/// <summary>
		/// Gets the lock that should be used by the object.
		/// </summary>
		public object DisposeLock
		{
			get
			{
				return fDisposeLock;
			}
		}

		/// <summary>
		/// Gets the exception that caused the Dispose, if any.
		/// </summary>
		public Exception DisposeException { get; private set; }

		/// <summary>
		/// Gets a value indicating if this object was already disposed.
		/// </summary>
		public bool WasDisposed { get; private set; }

		/// <summary>
		/// Checks if this object was disposed. If it is, throws an exception.
		/// </summary>
		public void CheckUndisposed()
		{
			var disposeException = DisposeException;
			if (disposeException != null)
				throw new ObjectDisposedException("Object disposed: " + GetType().FullName, disposeException);
			
			if (WasDisposed)
				throw new ObjectDisposedException(GetType().FullName);
		}
	}
}