WPF Control Factory

using System;
using System.Reflection;
using System.Security.Permissions;
using Pfz;

namespace Pfz
{
	/// <summary>
	/// This is an abstract class that implements the ICloneable interface using 
	/// the MemberwiseClone method and then clones all ICloneable fields.
	/// </summary>
	[Serializable]
	public abstract class Cloneable:
		ICloneable
	{
		#region Clone
			/// <summary>
			/// Clones this object and also all it's fields that references ICloneable objects.
			/// </summary>
			/// <returns>A memberwise cloned object, with all fields that are ICloneable also cloned.</returns>
			[ReflectionPermission(SecurityAction.Assert, RestrictedMemberAccess=true)]
			internal protected virtual Cloneable Clone()
			{
				object clonedCloneable = MemberwiseClone();
				
				Type type = GetType();
				foreach(FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
				{
					Type fieldType = field.FieldType;
					
					if (field.IsInitOnly)
						continue;
						
					object value = field.GetValue(this);

					ICloneable cloneable = value as ICloneable;
					if (cloneable != null)
					{
						object clonedFieldValue = cloneable.Clone();
						field.SetValue(clonedCloneable, clonedFieldValue);
					}
				}
				
				return (Cloneable)clonedCloneable;
			}
		#endregion
	
		#region ICloneable Members
			object ICloneable.Clone()
			{
				return Clone();
			}
		#endregion
	}

	/// <summary>
	/// This extension class simple creates the typed Clone method to the Cloneable,
	/// object, so you clone the object and don't need to cast it to the right type.
	/// </summary>
	public static class Cloneable_Extensions
	{
		/// <summary>
		/// Clones the cloneable object and return the clone with the same type
		/// as the original object is seen.
		/// </summary>
		/// <typeparam name="T">The type of the cloneable object.</typeparam>
		/// <param name="cloneable">The object to clone.</param>
		/// <returns>The right-typed clone.</returns>
		public static T Clone<T>(this T cloneable)
		where
			T: Cloneable
		{
			return (T)cloneable.Clone();
		}
	}
}