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();