From a0a99e8f12ac9e730a358340ed99fa9e90c1969a Mon Sep 17 00:00:00 2001
From: "shannon@ShandemVaio" <unknown@kiln.example.com>
Date: Wed, 1 Aug 2012 09:49:10 +0600
Subject: [PATCH] Obsoletes umbraco.presentation.cache with new
 Umbraco.Core.CacheRefreshersResolver Have removed ResolverBase as we cannot
 rely on manually setting the current singleton object since applications
 outside of the standard umbraco web application might be using these
 singletons and would expect they already be setup. Have changed all current
 resolvers to manage their own singleton instances and sealed them.

---
 src/Umbraco.Core/CacheRefreshersResolver.cs   |  99 ++++++++
 src/Umbraco.Core/PluginTypeResolver.cs        |  52 ++--
 .../Resolving/ManyObjectResolverBase.cs       | 223 ++++++++++++++----
 .../Resolving/ObjectLifetimeScope.cs          |   9 +
 src/Umbraco.Core/Resolving/ResolverBase.cs    |  42 ----
 .../Resolving/SingleObjectResolverBase.cs     |   4 +-
 src/Umbraco.Core/Umbraco.Core.csproj          |   9 +-
 .../CacheRefresherFactoryTests.cs             |  10 +-
 src/Umbraco.Tests/DataTypeFactoryTests.cs     |  12 +-
 src/Umbraco.Tests/PluginTypeResolverTests.cs  |   3 +-
 .../PluginTypeResolverExtensions.cs           |  10 -
 .../Routing/DocumentLookupsResolver.cs        | 112 +++------
 src/Umbraco.Web/Routing/DocumentRequest.cs    |   7 +-
 .../Routing/LastChanceLookupResolver.cs       |  45 ++++
 .../Routing/RoutesCacheResolver.cs            |  29 ++-
 src/Umbraco.Web/Routing/RoutingContext.cs     |  20 +-
 src/Umbraco.Web/Umbraco.Web.csproj            |   2 +
 src/Umbraco.Web/UmbracoApplication.cs         |  21 +-
 src/Umbraco.Web/UmbracoModule.cs              |   3 +-
 .../umbraco/cache/dispatcher.cs               |   5 +-
 .../umbraco/cache/factory.cs                  |  54 +----
 .../webservices/CacheRefresher.asmx.cs        |  11 +-
 src/umbraco.businesslogic/Utils/Singleton.cs  |  10 +-
 .../businesslogic/datatype/factory.cs         |   2 +-
 24 files changed, 467 insertions(+), 327 deletions(-)
 create mode 100644 src/Umbraco.Core/CacheRefreshersResolver.cs
 create mode 100644 src/Umbraco.Core/Resolving/ObjectLifetimeScope.cs
 delete mode 100644 src/Umbraco.Core/Resolving/ResolverBase.cs
 create mode 100644 src/Umbraco.Web/Routing/LastChanceLookupResolver.cs

diff --git a/src/Umbraco.Core/CacheRefreshersResolver.cs b/src/Umbraco.Core/CacheRefreshersResolver.cs
new file mode 100644
index 0000000000..9b363b4a80
--- /dev/null
+++ b/src/Umbraco.Core/CacheRefreshersResolver.cs
@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using Umbraco.Core.Resolving;
+using umbraco.interfaces;
+
+namespace Umbraco.Core
+{
+	internal sealed class CacheRefreshersResolver : ManyObjectResolverBase<ICacheRefresher>
+	{
+
+		#region Singleton
+
+		private static readonly CacheRefreshersResolver Instance = new CacheRefreshersResolver(PluginTypeResolver.Current.ResolveCacheRefreshers());
+
+		public static CacheRefreshersResolver Current
+		{
+			get { return Instance; }
+		}
+		#endregion
+
+		#region Constructors
+		static CacheRefreshersResolver() { }
+
+		/// <summary>
+		/// Constructor
+		/// </summary>
+		/// <param name="refreshers"></param>
+		/// <remarks>
+		/// We are creating Transient instances (new instances each time) because this is how the legacy code worked and
+		/// I don't want to muck anything up by changing them to application based instances. 
+		/// TODO: However, it would make much more sense to do this and would speed up the application plus this would make the GetById method much easier.
+		/// </remarks>
+		internal CacheRefreshersResolver(IEnumerable<Type> refreshers)
+			: base(true)
+		{
+			foreach (var l in refreshers)
+			{
+				this.Add(l);
+			}
+		}
+		#endregion
+
+		/// <summary>
+		/// Maintains a list of Ids and their types when first call to CacheResolvers or GetById occurs, this is used
+		/// in order to return a single object by id without instantiating the entire type stack.
+		/// </summary>
+		private static ConcurrentDictionary<Guid, Type> _refreshers;
+		private readonly ReaderWriterLockSlim _lock= new ReaderWriterLockSlim();
+
+		/// <summary>
+		/// Gets the <see cref="ICacheRefresher"/> implementations.
+		/// </summary>
+		public IEnumerable<ICacheRefresher> CacheResolvers
+		{
+			get
+			{
+				EnsureRefreshersList();
+				return Values;
+			}
+		}
+
+		/// <summary>
+		/// Returns a new ICacheRefresher instance by id
+		/// </summary>
+		/// <param name="id"></param>
+		/// <returns></returns>
+		public ICacheRefresher GetById(Guid id)
+		{
+			EnsureRefreshersList();
+			return !_refreshers.ContainsKey(id)
+			       	? null
+			       	: PluginTypeResolver.Current.CreateInstance<ICacheRefresher>(_refreshers[id]);
+		}
+
+		/// <summary>
+		/// Populates the refreshers dictionary to allow us to instantiate a type by Id since the ICacheRefresher type doesn't contain any metadata
+		/// </summary>
+		private void EnsureRefreshersList()
+		{
+			using (var l = new UpgradeableReadLock(_lock))
+			{
+				if (_refreshers == null)
+				{
+					l.UpgradeToWriteLock();
+					_refreshers = new ConcurrentDictionary<Guid, Type>();
+					foreach(var v in Values)
+					{
+						_refreshers.TryAdd(v.UniqueIdentifier, v.GetType());
+					}
+				}
+			}
+		}
+		
+	}
+}
diff --git a/src/Umbraco.Core/PluginTypeResolver.cs b/src/Umbraco.Core/PluginTypeResolver.cs
index 957f501529..c1218233aa 100644
--- a/src/Umbraco.Core/PluginTypeResolver.cs
+++ b/src/Umbraco.Core/PluginTypeResolver.cs
@@ -6,6 +6,7 @@ using System.Reflection;
 using System.Text;
 using System.Threading;
 using Umbraco.Core.Logging;
+using umbraco.interfaces;
 
 namespace Umbraco.Core
 {
@@ -40,22 +41,32 @@ namespace Umbraco.Core
 		{
 			get
 			{
-				if (_resolver == null)
+				using (var l = new UpgradeableReadLock(Lock))
 				{
-					using (new WriteLock(Lock))
+					if (_resolver == null)
 					{
+						l.UpgradeToWriteLock();
 						_resolver = new PluginTypeResolver();
-					}					
+					}
+					return _resolver;
 				}
-				return _resolver;
 			}
 			set { _resolver = value; }
 		}
-		
+
 		private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
 		private readonly HashSet<TypeList> _types = new HashSet<TypeList>();
 		private IEnumerable<Assembly> _assemblies;
 
+		/// <summary>
+		/// Returns all classes attributed with XsltExtensionAttribute attribute
+		/// </summary>
+		/// <returns></returns>
+		internal IEnumerable<Type> ResolveCacheRefreshers()
+		{
+			return ResolveTypes<ICacheRefresher>();
+		}
+
 		/// <summary>
 		/// Gets/sets which assemblies to scan when type finding, generally used for unit testing, if not explicitly set
 		/// this will search all assemblies known to have plugins and exclude ones known to not have them.
@@ -89,8 +100,8 @@ namespace Umbraco.Core
 		{
 			var typesAsArray = types.ToArray();
 			using (DisposableTimer.DebugDuration<PluginTypeResolver>(
-				string.Format("Starting instantiation of {0} objects of type {1}", typesAsArray.Length, typeof(T).FullName),
-				string.Format("Completed instantiation of {0} objects of type {1}", typesAsArray.Length, typeof(T).FullName)))
+				String.Format("Starting instantiation of {0} objects of type {1}", typesAsArray.Length, typeof(T).FullName),
+				String.Format("Completed instantiation of {0} objects of type {1}", typesAsArray.Length, typeof(T).FullName)))
 			{
 				var instances = new List<T>();
 				foreach (var t in typesAsArray)
@@ -102,17 +113,17 @@ namespace Umbraco.Core
 					}
 					catch (Exception ex)
 					{
-						
-						LogHelper.Error<PluginTypeResolver>(string.Format("Error creating type {0}", t.FullName), ex);
-						
+
+						LogHelper.Error<PluginTypeResolver>(String.Format("Error creating type {0}", t.FullName), ex);
+
 						if (throwException)
 						{
 							throw ex;
 						}
 					}
 				}
-				return instances;	
-			}			
+				return instances;
+			}
 		}
 
 		/// <summary>
@@ -124,7 +135,7 @@ namespace Umbraco.Core
 		/// <returns></returns>
 		internal T CreateInstance<T>(Type type, bool throwException = false)
 		{
-			var instances = CreateInstances<T>(new[] {type}, throwException);
+			var instances = CreateInstances<T>(new[] { type }, throwException);
 			return instances.FirstOrDefault();
 		}
 
@@ -133,8 +144,8 @@ namespace Umbraco.Core
 			using (var readLock = new UpgradeableReadLock(_lock))
 			{
 				using (DisposableTimer.TraceDuration<PluginTypeResolver>(
-					string.Format("Starting resolution types of {0}", typeof(T).FullName),
-					string.Format("Completed resolution of types of {0}", typeof(T).FullName)))
+					String.Format("Starting resolution types of {0}", typeof(T).FullName),
+					String.Format("Completed resolution of types of {0}", typeof(T).FullName)))
 				{
 					//check if the TypeList already exists, if so return it, if not we'll create it
 					var typeList = _types.SingleOrDefault(x => x.GetListType().IsType<T>());
@@ -153,8 +164,8 @@ namespace Umbraco.Core
 						//add the type list to the collection
 						_types.Add(typeList);
 					}
-					return typeList.GetTypes();	
-				}				
+					return typeList.GetTypes();
+				}
 			}
 		}
 
@@ -185,13 +196,13 @@ namespace Umbraco.Core
 		/// </summary>
 		/// <typeparam name="TAttribute"></typeparam>
 		/// <returns></returns>
-		internal IEnumerable<Type> ResolveAttributedTypes<TAttribute>() 
+		internal IEnumerable<Type> ResolveAttributedTypes<TAttribute>()
 			where TAttribute : Attribute
 		{
 			return ResolveTypes<TAttribute>(
-				() => TypeFinder2.FindClassesWithAttribute<TAttribute>(AssembliesToScan), 
+				() => TypeFinder2.FindClassesWithAttribute<TAttribute>(AssembliesToScan),
 				true);
-		} 
+		}
 
 		/// <summary>
 		/// Used for unit tests
@@ -244,6 +255,5 @@ namespace Umbraco.Core
 			}
 		}
 		#endregion
-
 	}
 }
diff --git a/src/Umbraco.Core/Resolving/ManyObjectResolverBase.cs b/src/Umbraco.Core/Resolving/ManyObjectResolverBase.cs
index 47dfa296a3..83e747cb03 100644
--- a/src/Umbraco.Core/Resolving/ManyObjectResolverBase.cs
+++ b/src/Umbraco.Core/Resolving/ManyObjectResolverBase.cs
@@ -1,114 +1,237 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
+using System.Web;
 
 namespace Umbraco.Core.Resolving
 {
-
-	/// <summary>
-	/// A Resolver which manages an ordered list of objects.
-	/// </summary>
-	/// <typeparam name="TResolver">The type of the resolver.</typeparam>
-	/// <typeparam name="TResolved">The type of the resolved objects.</typeparam>
-	/// <remarks>
-	/// Used to resolve multiple types from a collection. The collection can also be modified at runtime/application startup.
-	/// An example of this is MVCs ViewEngines collection.
-	/// </remarks>
-	internal abstract class ManyObjectResolverBase<TResolver, TResolved> : ResolverBase<TResolver> 
-		where TResolver : class 
+	internal abstract class ManyObjectResolverBase<TResolved>
 		where TResolved : class
 	{
-		readonly List<TResolved> _resolved;
-		protected readonly ReaderWriterLockSlim Lock = new ReaderWriterLockSlim();
-
+		private readonly bool _instancePerApplication = false;		
+		private List<TResolved> _applicationInstances = null;
+		private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
+		
+		#region Constructors
 		/// <summary>
-		/// Initializes a new instance of the <see cref="ManyObjectResolverBase{TResolver,TResolved}"/> class with an empty list of objects.
+		/// Initializes a new instance of the <see cref="ManyObjectResolverBase{TResolved}"/> class with an empty list of objects.
 		/// </summary>
-		protected ManyObjectResolverBase()
+		/// <param name="instancePerApplication">If set to true will resolve singleton objects which will be created once for the lifetime of the application</param>
+		protected ManyObjectResolverBase(bool instancePerApplication = true)
 		{
-			_resolved = new List<TResolved>();
+			_instancePerApplication = instancePerApplication;
+			InstanceTypes = new List<Type>();
 		}
 
 		/// <summary>
-		/// Initializes a new instance of the <see cref="ManyObjectResolverBase{TResolver,TResolved}"/> class with an initial list of objects.
+		/// Initializes a new instance of the <see cref="ManyObjectResolverBase{TResolved}"/> class with an initial list of objects
+		/// with creation of objects based on an HttpRequest lifetime scope.
+		/// </summary>
+		/// <param name="httpContext"></param>
+		protected ManyObjectResolverBase(HttpContextBase httpContext)
+			: this(false)
+		{
+			CurrentHttpContext = httpContext;
+		}
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="ManyObjectResolverBase{TResolved}"/> class with an initial list of objects.
 		/// </summary>
 		/// <param name="value">The list of objects.</param>
-		protected ManyObjectResolverBase(IEnumerable<TResolved> value)
+		/// <param name="instancePerApplication">If set to true will resolve singleton objects which will be created once for the lifetime of the application</param>
+		protected ManyObjectResolverBase(IEnumerable<Type> value, bool instancePerApplication = true)
 		{
-			_resolved = new List<TResolved>(value);
+			_instancePerApplication = instancePerApplication;
+			InstanceTypes = new List<Type>(value);
 		}
 
 		/// <summary>
-		/// Gets the list of objects.
+		/// Initializes a new instance of the <see cref="ManyObjectResolverBase{TResolved}"/> class with an empty list of objects
+		/// with creation of objects based on an HttpRequest lifetime scope.
+		/// </summary>
+		/// <param name="httpContext"></param>
+		/// <param name="value"></param>
+		protected ManyObjectResolverBase(HttpContextBase httpContext, IEnumerable<Type> value)
+			: this(value, false)
+		{
+			CurrentHttpContext = httpContext;
+		} 
+		#endregion
+
+		/// <summary>
+		/// Returns the list of Types registered that instances will be created from
+		/// </summary>
+		protected List<Type> InstanceTypes { get; private set; }
+
+		/// <summary>
+		/// Returns the Current HttpContextBase used to construct this object if one exists. 
+		/// If one exists then the LifetimeScope will be ObjectLifetimeScope.HttpRequest
+		/// </summary>
+		protected HttpContextBase CurrentHttpContext { get; private set; }
+
+		/// <summary>
+		/// Returns the ObjectLifetimeScope for created objects
+		/// </summary>
+		protected ObjectLifetimeScope LifetimeScope
+		{
+			get
+			{
+				if (_instancePerApplication)
+					return ObjectLifetimeScope.Application;
+				if (CurrentHttpContext != null)
+					return ObjectLifetimeScope.HttpRequest;
+				return ObjectLifetimeScope.Transient;
+			}
+		}
+
+		/// <summary>
+		/// Returns the list of new object instances.
 		/// </summary>
 		protected IEnumerable<TResolved> Values
 		{
-			get { return _resolved; }
-		}
+			get
+			{
+				//we should not allow the returning/creating of objects if resolution is not yet frozen!
+				if (Resolution.IsFrozen)
+					throw new InvalidOperationException("Resolution is not frozen. It is not possible to instantiate and returng objects until resolution is frozen.");
 
-		/// <summary>
-		/// Removes an object.
-		/// </summary>
-		/// <param name="value">The object to remove.</param>
-		public void Remove(TResolved value)
-		{
-			Resolution.EnsureNotFrozen();
-			using (new WriteLock(Lock))
-			{							
-				_resolved.Remove(value);
+				switch (LifetimeScope)
+				{
+					case ObjectLifetimeScope.HttpRequest:
+						//create new instances per HttpContext, this means we'll lazily create them and once created, cache them in the HttpContext
+						//create new instances per application, this means we'll lazily create them and once created, cache them
+						using (var l = new UpgradeableReadLock(_lock))
+						{
+							//check if the items contain the key (based on the full type name)
+							if (CurrentHttpContext.Items[this.GetType().FullName] == null)
+							{
+								l.UpgradeToWriteLock();
+								//add the items to the context items (based on full type name)
+								CurrentHttpContext.Items[this.GetType().FullName] = new List<TResolved>(
+									PluginTypeResolver.Current.CreateInstances<TResolved>(InstanceTypes));
+							}
+							return _applicationInstances;
+						}
+					case ObjectLifetimeScope.Application:
+						//create new instances per application, this means we'll lazily create them and once created, cache them
+						using(var l = new UpgradeableReadLock(_lock))
+						{
+							if (_applicationInstances == null)
+							{
+								l.UpgradeToWriteLock();
+								_applicationInstances = new List<TResolved>(
+									PluginTypeResolver.Current.CreateInstances<TResolved>(InstanceTypes));
+							}
+							return _applicationInstances;
+						}
+					case ObjectLifetimeScope.Transient:
+					default:
+						//create new instances each time
+						return PluginTypeResolver.Current.CreateInstances<TResolved>(InstanceTypes);
+				}				
 			}
 		}
 
 		/// <summary>
-		/// Adds an object to the end of the list.
+		/// Removes a type.
+		/// </summary>
+		/// <param name="value">The type to remove.</param>
+		public void Remove(Type value)
+		{
+			Resolution.EnsureNotFrozen();
+			EnsureCorrectType(value);
+			using (new WriteLock(_lock))
+			{
+				InstanceTypes.Remove(value);
+			}
+		}
+
+		/// <summary>
+		/// Removes a type.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		public void Remove<T>()
+		{
+			Remove(typeof (T));
+		}
+
+		/// <summary>
+		/// Adds a Type to the end of the list.
 		/// </summary>
 		/// <param name="value">The object to be added.</param>
-		public void Add(TResolved value)
+		public void Add(Type value)
 		{
 			Resolution.EnsureNotFrozen();
-			using (var l = new UpgradeableReadLock(Lock))
+			EnsureCorrectType(value);
+			using (var l = new UpgradeableReadLock(_lock))
 			{
-				if (_resolved.Contains(value))
+				if (InstanceTypes.Contains(value))
 				{
-					throw new InvalidOperationException("The object " + value + " already exists in the collection");
+					throw new InvalidOperationException("The Type " + value + " already exists in the collection");
 				};
-				
+
 				l.UpgradeToWriteLock();
-				_resolved.Add(value);
+				InstanceTypes.Add(value);
 			}
 		}
 
+		/// <summary>
+		/// Adds a Type to the end of the list.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		public void Add<T>()
+		{
+			Add(typeof (T));
+		}
+
 		/// <summary>
 		/// Clears the list.
 		/// </summary>
 		public void Clear()
 		{
 			Resolution.EnsureNotFrozen();
-			using (new WriteLock(Lock))
+			using (new WriteLock(_lock))
 			{
-				_resolved.Clear();
+				InstanceTypes.Clear();
 			}
 		}
 
 		/// <summary>
-		/// Inserts an object at the specified index.
+		/// Inserts a Type at the specified index.
 		/// </summary>
 		/// <param name="index">The zero-based index at which the object should be inserted.</param>
 		/// <param name="value">The object to insert.</param>
-		public void Insert(int index, TResolved value)
+		public void Insert(int index, Type value)
 		{
 			Resolution.EnsureNotFrozen();
-			using (var l = new UpgradeableReadLock(Lock))
+			EnsureCorrectType(value);
+			using (var l = new UpgradeableReadLock(_lock))
 			{
-				if (_resolved.Contains(value))
+				if (InstanceTypes.Contains(value))
 				{
-					throw new InvalidOperationException("The object " + value + " already exists in the collection");
+					throw new InvalidOperationException("The Type " + value + " already exists in the collection");
 				};
 
 				l.UpgradeToWriteLock();
-				_resolved.Insert(index, value);
+				InstanceTypes.Insert(index, value);
 			}
 		}
-		
+
+		/// <summary>
+		/// Inserts a Type at the specified index.
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="index"></param>
+		public void Insert<T>(int index)
+		{
+			Insert(index, typeof (T));
+		}
+
+		private void EnsureCorrectType(Type t)
+		{
+			if (!TypeHelper.IsTypeAssignableFrom<TResolved>(t))
+				throw new InvalidOperationException("The resolver " + this.GetType() + " can only accept types of " + typeof(TResolved) + ". The Type passed in to this method is " + t);
+		}
+
 	}
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Resolving/ObjectLifetimeScope.cs b/src/Umbraco.Core/Resolving/ObjectLifetimeScope.cs
new file mode 100644
index 0000000000..8c290ff54b
--- /dev/null
+++ b/src/Umbraco.Core/Resolving/ObjectLifetimeScope.cs
@@ -0,0 +1,9 @@
+namespace Umbraco.Core.Resolving
+{
+	internal enum ObjectLifetimeScope
+	{
+		HttpRequest,
+		Application,
+		Transient
+	}
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Resolving/ResolverBase.cs b/src/Umbraco.Core/Resolving/ResolverBase.cs
deleted file mode 100644
index 56c0bcd735..0000000000
--- a/src/Umbraco.Core/Resolving/ResolverBase.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-using System;
-using System.Threading;
-
-namespace Umbraco.Core.Resolving
-{
-	/// <summary>
-	/// base class for resolvers which declare a singleton accessor
-	/// </summary>
-	/// <typeparam name="TResolver"></typeparam>
-	internal abstract class ResolverBase<TResolver> where TResolver : class
-	{
-		static TResolver _resolver;
-
-		//TODO: This is not correct, this will be the same lock for all ResolverBase classes!!
-		static readonly ReaderWriterLockSlim ResolversLock = new ReaderWriterLockSlim();
-
-		public static TResolver Current
-		{
-			get
-			{
-				using (new ReadLock(ResolversLock))
-				{
-					if (_resolver == null)
-						throw new InvalidOperationException("Current has not been initialized. You must initialize Current before trying to read it.");
-					return _resolver;
-				}
-			}
-
-			set
-			{
-				using (new WriteLock(ResolversLock))
-				{
-					if (value == null)
-						throw new ArgumentNullException("value");
-					if (_resolver != null)
-						throw new InvalidOperationException("Current has already been initialized. It is not possible to re-initialize Current once it has been initialized.");
-					_resolver = value;
-				}
-			}
-		}
-	}
-}
diff --git a/src/Umbraco.Core/Resolving/SingleObjectResolverBase.cs b/src/Umbraco.Core/Resolving/SingleObjectResolverBase.cs
index a77d98f680..c793627c0d 100644
--- a/src/Umbraco.Core/Resolving/SingleObjectResolverBase.cs
+++ b/src/Umbraco.Core/Resolving/SingleObjectResolverBase.cs
@@ -5,14 +5,12 @@ namespace Umbraco.Core.Resolving
 	/// <summary>
 	/// A Resolver to return and set a Single registered object.
 	/// </summary>
-	/// <typeparam name="TResolver"></typeparam>
 	/// <typeparam name="TResolved"></typeparam>
 	/// <remarks>
 	/// Used for 'singly' registered objects. An example is like the MVC Controller Factory, only one exists application wide and it can
 	/// be get/set.
 	/// </remarks>
-	internal abstract class SingleObjectResolverBase<TResolver, TResolved> : ResolverBase<TResolver> 
-		where TResolver : class 
+	internal abstract class SingleObjectResolverBase<TResolved>
 		where TResolved : class
 	{
 		TResolved _resolved;
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index ce596fc188..9d8780f644 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -50,6 +50,7 @@
     </Compile>
     <Compile Include="ApplicationContext.cs" />
     <Compile Include="Attempt.cs" />
+    <Compile Include="CacheRefreshersResolver.cs" />
     <Compile Include="Configuration\GlobalSettings.cs" />
     <Compile Include="Configuration\UmbracoSettings.cs" />
     <Compile Include="CustomBooleanTypeConverter.cs" />
@@ -68,8 +69,8 @@
     <Compile Include="ObjectExtensions.cs" />
     <Compile Include="RazorDataTypeModelStaticMappingItem.cs" />
     <Compile Include="Resolving\ManyObjectResolverBase.cs" />
+    <Compile Include="Resolving\ObjectLifetimeScope.cs" />
     <Compile Include="Resolving\Resolution.cs" />
-    <Compile Include="Resolving\ResolverBase.cs" />
     <Compile Include="Resolving\SingleObjectResolverBase.cs" />
     <Compile Include="TypeExtensions.cs" />
     <Compile Include="ReadLock.cs" />
@@ -93,6 +94,12 @@
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\umbraco.interfaces\umbraco.interfaces.csproj">
+      <Project>{511F6D8D-7717-440A-9A57-A507E9A8B27F}</Project>
+      <Name>umbraco.interfaces</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/src/Umbraco.Tests/CacheRefresherFactoryTests.cs b/src/Umbraco.Tests/CacheRefresherFactoryTests.cs
index aa9685be23..51c9a9ffa4 100644
--- a/src/Umbraco.Tests/CacheRefresherFactoryTests.cs
+++ b/src/Umbraco.Tests/CacheRefresherFactoryTests.cs
@@ -25,17 +25,9 @@ namespace Umbraco.Tests
 				};
 		}
 
-		[Test]
-		public void Find_All_Refreshers()
-		{
-			umbraco.presentation.cache.Factory.Initialize();
-			Assert.AreEqual(2, umbraco.presentation.cache.Factory._refreshers.Count);
-		}
-
 		[Test]
 		public void Get_All_Instances()
-		{
-			umbraco.presentation.cache.Factory.Initialize();
+		{			
 			var factory = new umbraco.presentation.cache.Factory();
 			Assert.AreEqual(2, factory.GetAll().Count());
 		}
diff --git a/src/Umbraco.Tests/DataTypeFactoryTests.cs b/src/Umbraco.Tests/DataTypeFactoryTests.cs
index 263d06c846..eb31e16f1c 100644
--- a/src/Umbraco.Tests/DataTypeFactoryTests.cs
+++ b/src/Umbraco.Tests/DataTypeFactoryTests.cs
@@ -1,19 +1,10 @@
 using System;
 using NUnit.Framework;
-using SqlCE4Umbraco;
 using Umbraco.Core;
 using Umbraco.Tests.TestHelpers;
-using Umbraco.Web;
-using umbraco.DataLayer;
-using umbraco.MacroEngines;
-using umbraco.MacroEngines.Iron;
-using umbraco.businesslogic;
-using umbraco.cms.businesslogic;
 using umbraco.cms.businesslogic.datatype;
 using umbraco.interfaces;
-using umbraco.uicontrols;
 using System.Linq;
-using BaseDataType = umbraco.editorControls.BaseDataType;
 
 namespace Umbraco.Tests
 {
@@ -38,14 +29,13 @@ namespace Umbraco.Tests
 		[Test]
 		public void Find_All_DataTypes()
 		{
-			umbraco.cms.businesslogic.datatype.controls.Factory.Initialize();
+			var factory = new umbraco.cms.businesslogic.datatype.controls.Factory();
 			Assert.AreEqual(2, umbraco.cms.businesslogic.datatype.controls.Factory._controls.Count);
 		}
 
 		[Test]
 		public void Get_All_Instances()
 		{
-			umbraco.cms.businesslogic.datatype.controls.Factory.Initialize();
 			var factory = new umbraco.cms.businesslogic.datatype.controls.Factory();
 			Assert.AreEqual(2, factory.GetAll().Count());
 		}
diff --git a/src/Umbraco.Tests/PluginTypeResolverTests.cs b/src/Umbraco.Tests/PluginTypeResolverTests.cs
index ffb4039f39..c954690536 100644
--- a/src/Umbraco.Tests/PluginTypeResolverTests.cs
+++ b/src/Umbraco.Tests/PluginTypeResolverTests.cs
@@ -31,6 +31,7 @@ namespace Umbraco.Tests
 			PluginTypeResolver.Current = new PluginTypeResolver();
 
 			//for testing, we'll specify which assemblies are scanned for the PluginTypeResolver
+			//TODO: Should probably update this so it only searches this assembly and add custom types to be found
 			PluginTypeResolver.Current.AssembliesToScan = new[]
 			    {
 			        this.GetType().Assembly, 
@@ -124,7 +125,7 @@ namespace Umbraco.Tests
 		public void Resolves_RestExtensions()
 		{
 			var types = PluginTypeResolver.Current.ResolveRestExtensions();
-			Assert.AreEqual(1, types.Count());
+			Assert.AreEqual(2, types.Count());
 		}
 
 		[Test]
diff --git a/src/Umbraco.Web/PluginTypeResolverExtensions.cs b/src/Umbraco.Web/PluginTypeResolverExtensions.cs
index 58733f3b2d..4e536dd6e9 100644
--- a/src/Umbraco.Web/PluginTypeResolverExtensions.cs
+++ b/src/Umbraco.Web/PluginTypeResolverExtensions.cs
@@ -44,15 +44,5 @@ namespace Umbraco.Web
 		{
 			return resolver.ResolveAttributedTypes<XsltExtensionAttribute>();
 		}
-
-		/// <summary>
-		/// Returns all classes attributed with XsltExtensionAttribute attribute
-		/// </summary>
-		/// <param name="resolver"></param>
-		/// <returns></returns>
-		internal static IEnumerable<Type> ResolveCacheRefreshers(this PluginTypeResolver resolver)
-		{
-			return resolver.ResolveTypes<ICacheRefresher>();
-		}
 	}
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/DocumentLookupsResolver.cs b/src/Umbraco.Web/Routing/DocumentLookupsResolver.cs
index 908edcfadd..85ecb11d79 100644
--- a/src/Umbraco.Web/Routing/DocumentLookupsResolver.cs
+++ b/src/Umbraco.Web/Routing/DocumentLookupsResolver.cs
@@ -9,34 +9,42 @@ using Umbraco.Core.Resolving;
 
 namespace Umbraco.Web.Routing
 {
-	class LastChanceLookupResolver : SingleObjectResolverBase<LastChanceLookupResolver, IDocumentLastChanceLookup>
+
+	/// <summary>
+	/// A multiply registered resolver to manage all IDocumentLookup objects
+	/// </summary>
+	internal sealed class DocumentLookupsResolver : ManyObjectResolverBase<IDocumentLookup>
 	{
-		public LastChanceLookupResolver(IDocumentLastChanceLookup lastChanceLookup)
-		{
-			Value = lastChanceLookup;
-		}
+		#region Singleton
+		private static readonly DocumentLookupsResolver Instance = new DocumentLookupsResolver(
+			//add all known resolvers in the correct order, devs can then modify this list on application startup either by binding to events
+			//or in their own global.asax. We could also in the future allow these to be plugin types to be searched by searching for 
+			//any IDocumentLookup with a supplied attribute and find them here and add them to the list
+				new[]
+					{
+						typeof (LookupByNiceUrl),
+						typeof (LookupById),
+						typeof (LookupByNiceUrlAndTemplate),
+						typeof (LookupByProfile),
+						typeof (LookupByAlias)
+					});
 
-		/// <summary>
-		/// Returns the Last Chance Lookup
-		/// </summary>
-		public IDocumentLastChanceLookup LastChanceLookup
+		public static DocumentLookupsResolver Current
 		{
-			get { return Value; }
-		}
-	}
+			get { return Instance; }
+		} 
+		#endregion
 
-	class DocumentLookupsResolver2 : ManyObjectResolverBase<DocumentLookupsResolver2, IDocumentLookup>
-	{
-		private readonly LastChanceLookupResolver _lastChanceLookupResolver;
-
-		internal DocumentLookupsResolver2(IEnumerable<IDocumentLookup> lookups, LastChanceLookupResolver lastChanceLookupResolver)
+		#region Constructors
+		static DocumentLookupsResolver() { }
+		internal DocumentLookupsResolver(IEnumerable<Type> lookups)
 		{
-			_lastChanceLookupResolver = lastChanceLookupResolver;
 			foreach (var l in lookups)
 			{
 				this.Add(l);
 			}
-		}
+		} 
+		#endregion
 
 		/// <summary>
 		/// Gets the <see cref="IDocumentLookup"/> implementations.
@@ -46,72 +54,6 @@ namespace Umbraco.Web.Routing
 			get { return Values; }
 		}
 
-		/// <summary>
-		/// Gets or sets the <see cref="IDocumentLastChanceLookup"/> implementation.
-		/// </summary>
-		public IDocumentLastChanceLookup DocumentLastChanceLookup
-		{
-			get { return _lastChanceLookupResolver.LastChanceLookup; }
-		}
 	}
 
-	///// <summary>
-	///// Resolves the <see cref="IDocumentLookup"/> implementations and the <see cref="IDocumentLastChanceLookup"/> implementation.
-	///// </summary>
-	//class DocumentLookupsResolver : ResolverBase<DocumentLookupsResolver>
-	//{
-	//    /// <summary>
-	//    /// Initializes a new instance of the <see cref="DocumentLookupsResolver"/> class with an enumeration of <see cref="IDocumentLookup"/> an an <see cref="IDocumentLastChanceLookup"/>.
-	//    /// </summary>
-	//    /// <param name="lookupTypes">The document lookups.</param>
-	//    /// <param name="lastChanceLookup">The document last chance lookup.</param>
-	//    internal DocumentLookupsResolver(IEnumerable<Type> lookupTypes, IDocumentLastChanceLookup lastChanceLookup)
-	//    {
-	//        //TODO: I've changed this to resolve types but the intances are not created yet!
-	//        // I've created a method on the PluginTypeResolver to create types: PluginTypesResolver.Current.FindAndCreateInstances<T>()
-
-
-	//        _lookupTypes.AddRange(lookupTypes);
-	//        _lastChanceLookup.Value = lastChanceLookup;
-	//    }
-
-	//    #region LastChanceLookup
-
-	//    readonly SingleResolved<IDocumentLastChanceLookup> _lastChanceLookup = new SingleResolved<IDocumentLastChanceLookup>(true);
-
-	//    /// <summary>
-	//    /// Gets or sets the <see cref="IDocumentLastChanceLookup"/> implementation.
-	//    /// </summary>
-	//    public IDocumentLastChanceLookup DocumentLastChanceLookup
-	//    {
-	//        get { return _lastChanceLookup.Value; }
-	//        set { _lastChanceLookup.Value = value; }
-	//    }
-
-	//    #endregion
-
-	//    #region Lookups
-
-	//    private readonly List<Type> _lookupTypes = new List<Type>(); 
-	//    readonly ManyWeightedResolved<IDocumentLookup> _lookups = new ManyWeightedResolved<IDocumentLookup>();
-
-	//    /// <summary>
-	//    /// Gets the <see cref="IDocumentLookup"/> implementations.
-	//    /// </summary>
-	//    public IEnumerable<IDocumentLookup> DocumentLookups
-	//    {
-	//        get { return _lookups.Values; }
-	//    }
-
-	//    //why do we have this?
-	//    /// <summary>
-	//    /// Gets the inner <see cref="IDocumentLookup"/> resolution.
-	//    /// </summary>
-	//    public ManyWeightedResolved<IDocumentLookup> DocumentLookupsResolution
-	//    {
-	//        get { return _lookups; }
-	//    }
-
-	//    #endregion
-	//}
 }
diff --git a/src/Umbraco.Web/Routing/DocumentRequest.cs b/src/Umbraco.Web/Routing/DocumentRequest.cs
index 95f76615b2..725954542e 100644
--- a/src/Umbraco.Web/Routing/DocumentRequest.cs
+++ b/src/Umbraco.Web/Routing/DocumentRequest.cs
@@ -209,9 +209,8 @@ namespace Umbraco.Web.Routing
 			using (DisposableTimer.DebugDuration<PluginTypeResolver>(
 				string.Format("{0}Begin resolvers", tracePrefix),
 				string.Format("{0}End resolvers, {1}", tracePrefix, (this.HasNode ? "a document was found" : "no document was found"))))
-			{
-				var lookups = RoutingContext.DocumentLookupsResolver.DocumentLookups;
-				lookups.Any(lookup => lookup.TrySetDocument(this));	
+			{				
+				RoutingContext.DocumentLookups.Any(lookup => lookup.TrySetDocument(this));	
 			}			
 
             // fixme - not handling umbracoRedirect
@@ -251,7 +250,7 @@ namespace Umbraco.Web.Routing
 					LogHelper.Debug<DocumentRequest>("{0}No document, try last chance lookup", () => tracePrefix);                    
 
                     // if it fails then give up, there isn't much more that we can do
-					var lastChance = RoutingContext.DocumentLookupsResolver.DocumentLastChanceLookup;
+					var lastChance = RoutingContext.DocumentLastChanceLookup;
 					if (lastChance == null || !lastChance.TrySetDocument(this))
                     {
 						LogHelper.Debug<DocumentRequest>("{0}Failed to find a document, give up", () => tracePrefix);
diff --git a/src/Umbraco.Web/Routing/LastChanceLookupResolver.cs b/src/Umbraco.Web/Routing/LastChanceLookupResolver.cs
new file mode 100644
index 0000000000..c5582ba86b
--- /dev/null
+++ b/src/Umbraco.Web/Routing/LastChanceLookupResolver.cs
@@ -0,0 +1,45 @@
+using Umbraco.Core.Resolving;
+
+namespace Umbraco.Web.Routing
+{
+
+	/// <summary>
+	/// A singly registered object resolver to manage the IDocumentLastChanceLookup
+	/// </summary>
+	internal sealed class LastChanceLookupResolver : SingleObjectResolverBase<IDocumentLastChanceLookup>
+	{
+		#region Singleton
+		private static readonly LastChanceLookupResolver Instance = new LastChanceLookupResolver(new DefaultLastChanceLookup());
+		public static LastChanceLookupResolver Current
+		{
+			get { return Instance; }
+		} 
+		#endregion
+
+		#region Constructors
+		static LastChanceLookupResolver() { }
+		internal LastChanceLookupResolver(IDocumentLastChanceLookup lastChanceLookup)
+		{
+			Value = lastChanceLookup;
+		} 
+		#endregion
+
+		/// <summary>
+		/// Can be used by developers at runtime to set their DocumentLastChanceLookup at app startup
+		/// </summary>
+		/// <param name="lastChanceLookup"></param>
+		public void SetLastChanceLookup(IDocumentLastChanceLookup lastChanceLookup)
+		{
+			Value = lastChanceLookup;
+		}
+
+		/// <summary>
+		/// Returns the Last Chance Lookup
+		/// </summary>
+		public IDocumentLastChanceLookup LastChanceLookup
+		{
+			get { return Value; }
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutesCacheResolver.cs b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
index 7ef5b11ebc..08dda9b427 100644
--- a/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
+++ b/src/Umbraco.Web/Routing/RoutesCacheResolver.cs
@@ -6,15 +6,39 @@ namespace Umbraco.Web.Routing
 	/// <summary>
 	/// Resolves the <see cref="IRoutesCache"/> implementation.
 	/// </summary>
-	class RoutesCacheResolver : SingleObjectResolverBase<RoutesCacheResolver, IRoutesCache>
+	internal sealed class RoutesCacheResolver : SingleObjectResolverBase<IRoutesCache>
 	{
+		#region Singleton
+
+		private static readonly RoutesCacheResolver Instance = new RoutesCacheResolver(new DefaultRoutesCache());
+
+		public static RoutesCacheResolver Current
+		{
+			get { return Instance; }
+		}
+		#endregion
+
+		#region Constructors
+		static RoutesCacheResolver() { }
 		/// <summary>
-		/// Initializes a new instance of the <see cref="RoutesCacheResolve"/> class with an <see cref="IRoutesCache"/> implementation.
+		/// Initializes a new instance of the <see cref="RoutesCacheResolver"/> class with an <see cref="IRoutesCache"/> implementation.
 		/// </summary>
 		/// <param name="routesCache">The <see cref="IRoutesCache"/> implementation.</param>
 		internal RoutesCacheResolver(IRoutesCache routesCache)
 			: base(routesCache)
 		{ }
+		#endregion
+
+
+
+		/// <summary>
+		/// Can be used by developers at runtime to set their IRoutesCache at app startup
+		/// </summary>
+		/// <param name="routesCache"></param>
+		public void SetRoutesCache(IRoutesCache routesCache)
+		{
+			Value = routesCache;
+		}
 
 		/// <summary>
 		/// Gets or sets the <see cref="IRoutesCache"/> implementation.
@@ -22,7 +46,6 @@ namespace Umbraco.Web.Routing
 		public IRoutesCache RoutesCache
 		{
 			get { return this.Value; }
-			set { this.Value = value; }
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Umbraco.Web/Routing/RoutingContext.cs b/src/Umbraco.Web/Routing/RoutingContext.cs
index d91568e44d..a4fed55ab2 100644
--- a/src/Umbraco.Web/Routing/RoutingContext.cs
+++ b/src/Umbraco.Web/Routing/RoutingContext.cs
@@ -13,18 +13,21 @@ namespace Umbraco.Web.Routing
 		/// Initializes a new instance of the <see cref="RoutingContext"/> class.
 		/// </summary>
 		/// <param name="umbracoContext">The Umbraco context.</param>
-		/// <param name="documentLookupsResolver">The document lookups resolver.</param>
+		/// <param name="documentLookups">The document lookups resolver.</param>
+		/// <param name="documentLastChanceLookup"> </param>
 		/// <param name="contentStore">The content store.</param>
 		/// <param name="niceUrlResolver">The nice urls resolver.</param>
-        internal RoutingContext(
+		internal RoutingContext(
 			UmbracoContext umbracoContext,
-			DocumentLookupsResolver2 documentLookupsResolver,
+			IEnumerable<IDocumentLookup> documentLookups,
+			IDocumentLastChanceLookup documentLastChanceLookup,
             ContentStore contentStore,
 			NiceUrlProvider niceUrlResolver)
         {
         	this.UmbracoContext = umbracoContext;
-			this.DocumentLookupsResolver = documentLookupsResolver;
-            this.ContentStore = contentStore;
+			this.DocumentLookups = documentLookups;
+			DocumentLastChanceLookup = documentLastChanceLookup;
+			this.ContentStore = contentStore;
         	this.NiceUrlProvider = niceUrlResolver;
         }
 
@@ -36,7 +39,12 @@ namespace Umbraco.Web.Routing
 		/// <summary>
 		/// Gets the document lookups resolver.
 		/// </summary>
-		internal DocumentLookupsResolver2 DocumentLookupsResolver { get; private set; }
+		internal IEnumerable<IDocumentLookup> DocumentLookups { get; private set; }
+
+		/// <summary>
+		/// Gets the last chance lookup
+		/// </summary>
+		internal IDocumentLastChanceLookup DocumentLastChanceLookup { get; private set; }
 
 		/// <summary>
 		/// Gets the content store.
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 21fe3318b6..dd04b8ac04 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -163,6 +163,7 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\WebPages\System.Web.Helpers.dll</HintPath>
     </Reference>
+    <Reference Include="System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
     <Reference Include="System.Web.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\WebPages\System.Web.Razor.dll</HintPath>
@@ -242,6 +243,7 @@
     <Compile Include="Mvc\ControllerExtensions.cs" />
     <Compile Include="Routing\DefaultLastChanceLookup.cs" />
     <Compile Include="Routing\IDocumentLastChanceLookup.cs" />
+    <Compile Include="Routing\LastChanceLookupResolver.cs" />
     <Compile Include="Routing\LookupByAlias.cs" />
     <Compile Include="Media\ThumbnailProviders\AbstractThumbnailProvider.cs" />
     <Compile Include="Media\ThumbnailProviders\MediaTypeIconThumbnailProvider.cs" />
diff --git a/src/Umbraco.Web/UmbracoApplication.cs b/src/Umbraco.Web/UmbracoApplication.cs
index 9d9003c1a6..402929c4c2 100644
--- a/src/Umbraco.Web/UmbracoApplication.cs
+++ b/src/Umbraco.Web/UmbracoApplication.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Text;
+using System.Web.Mvc;
 using Umbraco.Core;
 using Umbraco.Web.Routing;
 using umbraco.businesslogic;
@@ -42,24 +43,6 @@ namespace Umbraco.Web
 				//find and initialize the application startup handlers
 				ApplicationStartupHandler.RegisterHandlers();
 
-				// create the resolvers...
-				
-				LastChanceLookupResolver.Current = new LastChanceLookupResolver(new DefaultLastChanceLookup());
-
-				DocumentLookupsResolver2.Current = new DocumentLookupsResolver2(
-					//add all known resolvers in the correct order, devs can then modify this list on application startup either by binding to events
-					//or in their own global.asax
-					new IDocumentLookup[]
-						{
-							new LookupByNiceUrl(),
-							new LookupById(), 
-							new LookupByNiceUrlAndTemplate(),
- 							new LookupByProfile(),
-							new LookupByAlias()  
-						},
-					LastChanceLookupResolver.Current);
-				RoutesCacheResolver.Current = new RoutesCacheResolver(new DefaultRoutesCache());
-
 				OnApplicationStarting(sender, e);
 
 				//all resolvers are now frozen and cannot be modified
@@ -67,7 +50,7 @@ namespace Umbraco.Web
 
 				OnApplicationStarted(sender, e);
 			}
-		}
+		}		
 
 		/// <summary>
 		/// Developers can override this method to modify objects on startup
diff --git a/src/Umbraco.Web/UmbracoModule.cs b/src/Umbraco.Web/UmbracoModule.cs
index df9fa000a6..428f6ecd2e 100644
--- a/src/Umbraco.Web/UmbracoModule.cs
+++ b/src/Umbraco.Web/UmbracoModule.cs
@@ -62,7 +62,8 @@ namespace Umbraco.Web
 			//create the RoutingContext
 			var routingContext = new RoutingContext(
 				umbracoContext,
-				DocumentLookupsResolver2.Current,
+				DocumentLookupsResolver.Current.DocumentLookups,
+				LastChanceLookupResolver.Current.LastChanceLookup,
 				contentStore,
 				niceUrls);
 
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/cache/dispatcher.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/cache/dispatcher.cs
index a037b8b771..646542b4bf 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/cache/dispatcher.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/cache/dispatcher.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Net;
 using System.Threading;
 using System.Xml;
+using Umbraco.Core;
 using umbraco.BusinessLogic;
 using umbraco.interfaces;
 using umbraco.IO;
@@ -234,8 +235,8 @@ namespace umbraco.presentation.cache
         }
 
         private static string GetFactoryObjectName(Guid uniqueIdentifier)
-        {
-            ICacheRefresher cacheRefresher = new Factory().GetNewObject(uniqueIdentifier);
+        {            
+        	var cacheRefresher = CacheRefreshersResolver.Current.GetById(uniqueIdentifier);
 
             return cacheRefresher != null ? cacheRefresher.Name : "<error determining factory type>";
         }
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/cache/factory.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/cache/factory.cs
index 487666972a..1f6e3589b6 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/cache/factory.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/cache/factory.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Linq;
 using System.Web;
 using Umbraco.Core;
 using Umbraco.Web;
@@ -12,40 +13,12 @@ namespace umbraco.presentation.cache
     /// <summary>
     /// cache.factory uses reflection to find all registered instances of ICacheRefresher.
     /// </summary>
+	[Obsolete("Use Umbraco.Core.CacheRefreshersResolver instead")]
     public class Factory
-    {
-        #region Declarations
-
-		internal static readonly ConcurrentDictionary<Guid, Type> _refreshers = new ConcurrentDictionary<Guid, Type>();
-
-        #endregion
-
-        #region Constructors
-
-        /// <summary>
-        /// Initializes the <see cref="Factory"/> class.
-        /// </summary>
-        static Factory()
-        {
-            Initialize();
-        }
-
-        #endregion
+    {	
 
         #region Methods
-
-        internal static void Initialize()
-        {
-			foreach(var t in PluginTypeResolver.Current.ResolveCacheRefreshers())
-			{
-				var instance = PluginTypeResolver.Current.CreateInstance<ICacheRefresher>(t);
-				if (instance != null)
-				{
-					_refreshers.TryAdd(instance.UniqueIdentifier, t);	
-				}
-			}        	
-        }
-
+		
         public ICacheRefresher CacheRefresher(Guid CacheRefresherId)
         {
             return GetNewObject(CacheRefresherId);
@@ -58,9 +31,7 @@ namespace umbraco.presentation.cache
         /// <returns></returns>
         public ICacheRefresher GetNewObject(Guid CacheRefresherId)
         {
-        	return !_refreshers.ContainsKey(CacheRefresherId) 
-				? null 
-				: PluginTypeResolver.Current.CreateInstance<ICacheRefresher>(_refreshers[CacheRefresherId]);
+			return CacheRefreshersResolver.Current.GetById(CacheRefresherId);
         }
 
     	/// <summary>
@@ -68,18 +39,9 @@ namespace umbraco.presentation.cache
         /// </summary>
         /// <returns></returns>
         public ICacheRefresher[] GetAll()
-        {
-			var retVal = new ICacheRefresher[_refreshers.Count];
-			var c = 0;
-
-			foreach (var id in _refreshers.Keys)
-			{
-				retVal[c] = GetNewObject(id);
-				c++;
-			}
-
-			return retVal;
-        }
+    	{
+    		return CacheRefreshersResolver.Current.CacheResolvers.ToArray();    		
+    	}
 
         #endregion
     }
diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CacheRefresher.asmx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CacheRefresher.asmx.cs
index 0eafa29bd7..d2ecd05a33 100644
--- a/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CacheRefresher.asmx.cs
+++ b/src/Umbraco.Web/umbraco.presentation/umbraco/webservices/CacheRefresher.asmx.cs
@@ -6,6 +6,7 @@ using System.Diagnostics;
 using System.Web;
 using System.Web.Services;
 using System.Xml;
+using Umbraco.Core;
 
 namespace umbraco.presentation.webservices
 {
@@ -53,7 +54,7 @@ namespace umbraco.presentation.webservices
 		{
 			if (BusinessLogic.User.validateCredentials(Login, Password))
 			{
-				interfaces.ICacheRefresher cr = new cache.Factory().GetNewObject(uniqueIdentifier);
+				var cr = CacheRefreshersResolver.Current.GetById(uniqueIdentifier);
 				cr.RefreshAll();
 				
 			}
@@ -64,7 +65,7 @@ namespace umbraco.presentation.webservices
 		{
 			if (BusinessLogic.User.validateCredentials(Login, Password))
 			{
-				interfaces.ICacheRefresher cr = new cache.Factory().GetNewObject(uniqueIdentifier);
+				var cr = CacheRefreshersResolver.Current.GetById(uniqueIdentifier);
 				cr.Refresh(Id);
 				
 			}
@@ -75,7 +76,7 @@ namespace umbraco.presentation.webservices
 		{
 			if (BusinessLogic.User.validateCredentials(Login, Password))
 			{
-				interfaces.ICacheRefresher cr = new cache.Factory().GetNewObject(uniqueIdentifier);
+				var cr = CacheRefreshersResolver.Current.GetById(uniqueIdentifier);
 				cr.Refresh(Id);
 				
 			}
@@ -85,7 +86,7 @@ namespace umbraco.presentation.webservices
         public void RemoveById(Guid uniqueIdentifier, int Id, string Login, string Password) {
 
             if (BusinessLogic.User.validateCredentials(Login, Password)) {
-                interfaces.ICacheRefresher cr = new cache.Factory().GetNewObject(uniqueIdentifier);
+				var cr = CacheRefreshersResolver.Current.GetById(uniqueIdentifier);
                 cr.Remove(Id);
             }
         }
@@ -97,7 +98,7 @@ namespace umbraco.presentation.webservices
 			{
 				XmlDocument xd = new XmlDocument();
 				xd.LoadXml("<cacheRefreshers/>");
-				foreach (interfaces.ICacheRefresher cr in new cache.Factory().GetAll()) 
+				foreach (var cr in CacheRefreshersResolver.Current.CacheResolvers) 
 				{
 					XmlNode n = xmlHelper.addTextNode(xd, "cacheRefresher", cr.Name);
 					n.Attributes.Append(xmlHelper.addAttribute(xd, "uniqueIdentifier", cr.UniqueIdentifier.ToString()));
diff --git a/src/umbraco.businesslogic/Utils/Singleton.cs b/src/umbraco.businesslogic/Utils/Singleton.cs
index d509ba1bd5..8cf426d603 100644
--- a/src/umbraco.businesslogic/Utils/Singleton.cs
+++ b/src/umbraco.businesslogic/Utils/Singleton.cs
@@ -14,19 +14,15 @@ namespace umbraco.BusinessLogic.Utils
     ///		{
     ///			get
     ///			{
-    ///				return Singleton<Form1>.Instance;
+    ///				return Singleton{Form1}.Instance;
     ///			}
     ///		}
     ///	}
     /// </summary>
     /// <typeparam name="T">Any class that implements default constructor</typeparam>
-    public sealed class Singleton<T> where T : new()
+    public static class Singleton<T> where T : new()
     {
-        private Singleton()
-        {
-        }
-
-        public static T Instance
+    	public static T Instance
         {
             get { return Nested.instance; }
         }
diff --git a/src/umbraco.cms/businesslogic/datatype/factory.cs b/src/umbraco.cms/businesslogic/datatype/factory.cs
index 240742cddd..3eb3751a22 100644
--- a/src/umbraco.cms/businesslogic/datatype/factory.cs
+++ b/src/umbraco.cms/businesslogic/datatype/factory.cs
@@ -82,7 +82,7 @@ namespace umbraco.cms.businesslogic.datatype.controls
             return retVal;
         }
 
-        internal static void Initialize()
+        private static void Initialize()
         {
             // Get all datatypes from interface
         	var types = PluginTypeResolver.Current.ResolveDataTypes().ToArray();