diff --git a/src/Umbraco.Core/ApplicationContext.cs b/src/Umbraco.Core/ApplicationContext.cs
index 776714b839..db58fb7858 100644
--- a/src/Umbraco.Core/ApplicationContext.cs
+++ b/src/Umbraco.Core/ApplicationContext.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Configuration;
+using System.Threading;
 using System.Web;
 using System.Web.Caching;
 using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
+using Umbraco.Core.ObjectResolution;
 using Umbraco.Core.Services;
 
 
@@ -15,7 +17,7 @@ namespace Umbraco.Core
     /// <remarks>
     /// one per AppDomain, represents the global Umbraco application
     /// </remarks>
-    public class ApplicationContext
+    public class ApplicationContext : IDisposable
     {
     	/// <summary>
         /// Constructor
@@ -186,5 +188,38 @@ namespace Umbraco.Core
 			}
 			internal set { _services = value; }
 		}
+
+
+        private volatile bool _disposed;
+        private readonly ReaderWriterLockSlim _disposalLocker = new ReaderWriterLockSlim();
+
+        /// <summary>
+        /// This will dispose and reset all resources used to run the application
+        /// </summary>
+        /// <remarks>
+        /// IMPORTANT: Never dispose this object if you require the Umbraco application to run, disposing this object
+        /// is generally used for unit testing and when your application is shutting down after you have booted Umbraco.
+        /// </remarks>
+        void IDisposable.Dispose()
+        {
+            // Only operate if we haven't already disposed
+            if (_disposed) return;
+
+            using (new WriteLock(_disposalLocker))
+            {
+                // Check again now we're inside the lock
+                if (_disposed) return;
+
+                //First we'll reset all resolvers
+                ResolverCollection.ResetAll();
+                //Next resolution itself (though this should be taken care of by resetting any of the resolvers above)
+                Resolution.Reset();
+                //Next, lets reset the plugin manager
+                PluginManager.Current = null;
+                
+                // Indicate that the instance has been disposed.
+                _disposed = true;
+            }
+        }
     }
 }
diff --git a/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs b/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs
index f8476c790c..6aaf59106c 100644
--- a/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs
+++ b/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs
@@ -20,7 +20,7 @@ namespace Umbraco.Core.ObjectResolution
 	/// </remarks>
 	internal abstract class LazyManyObjectsResolverBase<TResolver, TResolved> : ManyObjectsResolverBase<TResolver, TResolved>
 		where TResolved : class
-		where TResolver : class
+        where TResolver : ResolverBase
 	{
 		#region Constructors
 		
diff --git a/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs b/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs
index eb871d4b73..9362ed54fe 100644
--- a/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs
+++ b/src/Umbraco.Core/ObjectResolution/LegacyTransientObjectsResolver.cs
@@ -19,7 +19,7 @@ namespace Umbraco.Core.ObjectResolution
 	/// </remarks>
 	internal abstract class LegacyTransientObjectsResolver<TResolver, TResolved> : LazyManyObjectsResolverBase<TResolver, TResolved>
 		where TResolved : class
-		where TResolver : class
+        where TResolver : ResolverBase
 	{
 		private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
 		private ConcurrentDictionary<Guid, Type> _id2type;
diff --git a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs
index 1a13f866d0..4a5f7cbd99 100644
--- a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs
+++ b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs
@@ -6,14 +6,14 @@ using System.Web;
 
 namespace Umbraco.Core.ObjectResolution
 {
-	/// <summary>
+    /// <summary>
 	/// The base class for all many-objects resolvers.
 	/// </summary>
 	/// <typeparam name="TResolver">The type of the concrete resolver class.</typeparam>
 	/// <typeparam name="TResolved">The type of the resolved objects.</typeparam>
 	public abstract class ManyObjectsResolverBase<TResolver, TResolved> : ResolverBase<TResolver>
-		where TResolved : class 
-		where TResolver : class
+		where TResolved : class
+        where TResolver : ResolverBase
 	{
 		private IEnumerable<TResolved> _applicationInstances = null;
 		private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
diff --git a/src/Umbraco.Core/ObjectResolution/ResolverBase.cs b/src/Umbraco.Core/ObjectResolution/ResolverBase.cs
index 1e542eae59..fd22a76610 100644
--- a/src/Umbraco.Core/ObjectResolution/ResolverBase.cs
+++ b/src/Umbraco.Core/ObjectResolution/ResolverBase.cs
@@ -3,26 +3,52 @@ using System.Threading;
 
 namespace Umbraco.Core.ObjectResolution
 {
+    /// <summary>
+    /// Base non-generic class for resolvers
+    /// </summary>
+    public abstract class ResolverBase
+    {
+        protected ResolverBase(Action resetAction)
+        {
+            //add itself to the internal collection
+            ResolverCollection.Add(this, resetAction);
+        }
+        
+    }
+
 	/// <summary>
 	/// The base class for all resolvers.
 	/// </summary>
 	/// <typeparam name="TResolver">The type of the concrete resolver class.</typeparam>
 	/// <remarks>Provides singleton management to all resolvers.</remarks>
-	public abstract class ResolverBase<TResolver> 
-		where TResolver : class
+    public abstract class ResolverBase<TResolver> : ResolverBase
+        where TResolver : ResolverBase
 	{
-		static TResolver _resolver;
-		
-		/// <summary>
-		/// The lock for the singleton.
-		/// </summary>
-		/// <remarks>
-		/// Though resharper says this is in error, it is actually correct. We want a different lock object for each generic type.
-		/// See this for details: http://confluence.jetbrains.net/display/ReSharper/Static+field+in+generic+type
-		/// </remarks>
-		static readonly ReaderWriterLockSlim ResolversLock = new ReaderWriterLockSlim();
 
-		/// <summary>
+        /// <summary>
+        /// The underlying singleton object instance
+        /// </summary>
+        static TResolver _resolver;
+
+        /// <summary>
+        /// The lock for the singleton.
+        /// </summary>
+        /// <remarks>
+        /// Though resharper says this is in error, it is actually correct. We want a different lock object for each generic type.
+        /// See this for details: http://confluence.jetbrains.net/display/ReSharper/Static+field+in+generic+type
+        /// </remarks>
+        static readonly ReaderWriterLockSlim ResolversLock = new ReaderWriterLockSlim();
+
+        /// <summary>
+        /// Constructor set the reset action for the underlying object
+        /// </summary>
+	    protected ResolverBase()
+	        : base(() => Reset())
+	    {
+
+	    }
+
+	    /// <summary>
 		/// Gets or sets the resolver singleton instance.
 		/// </summary>
 		/// <remarks>The value can be set only once, and cannot be read before it has been set.</remarks>
@@ -84,15 +110,18 @@ namespace Umbraco.Core.ObjectResolution
             //In order to reset a resolver, we always must reset the resolution
             if (resetResolution)
             {                
-                Resolution.Reset();    
+                Resolution.Reset();
             }
-            
+
+            //ensure its removed from the collection
+            ResolverCollection.Remove(_resolver);
 
             using (Resolution.Configuration)
 			using (new WriteLock(ResolversLock))
 			{
 				_resolver = null;
 			}
+            
 		}
 	}
 }
diff --git a/src/Umbraco.Core/ObjectResolution/ResolverCollection.cs b/src/Umbraco.Core/ObjectResolution/ResolverCollection.cs
new file mode 100644
index 0000000000..34a7ff68bc
--- /dev/null
+++ b/src/Umbraco.Core/ObjectResolution/ResolverCollection.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+
+namespace Umbraco.Core.ObjectResolution
+{
+    /// <summary>
+    /// Simply used to track all ManyObjectsResolverBase instances so that we can 
+    /// reset them all at once really easily. 
+    /// </summary>
+    /// <remarks>
+    /// Normally we'd use TypeFinding for this but because many of the resolvers are internal this won't work.
+    /// We'd rather not keep a static list of them so we'll dynamically add to this list based on the base
+    /// class of the ManyObjectsResolverBase.
+    /// </remarks>
+    internal static class ResolverCollection
+    {
+        private static readonly ConcurrentDictionary<ResolverBase, Action> Resolvers = new ConcurrentDictionary<ResolverBase, Action>();
+
+        /// <summary>
+        /// Returns the number of resolvers created
+        /// </summary>
+        internal static int Count
+        {
+            get { return Resolvers.Count; }
+        }
+
+        /// <summary>
+        /// Resets all resolvers
+        /// </summary>
+        internal static void ResetAll()
+        {
+            //take out each item from the bag and reset it
+            var keys = Resolvers.Keys.ToArray();
+            foreach (var k in keys)
+            {
+                Action resetAction;
+                while (Resolvers.TryRemove(k, out resetAction))
+                {
+                    //call the reset action for the resolver
+                    resetAction();
+                }
+            }
+        }
+
+        /// <summary>
+        /// This is called when the static Reset method or a ResolverBase{T} is called.
+        /// </summary>
+        internal static void Remove(ResolverBase resolver)
+        {
+            if (resolver == null) return;
+            Action action;
+            Resolvers.TryRemove(resolver, out action);
+        }
+
+        /// <summary>
+        /// Adds a resolver to the collection
+        /// </summary>
+        /// <param name="resolver"></param>
+        /// <param name="resetAction"></param>
+        /// <remarks>
+        /// This is called when the creation of a ResolverBase occurs
+        /// </remarks>
+        internal static void Add(ResolverBase resolver, Action resetAction)
+        {
+            Resolvers.TryAdd(resolver, resetAction);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/ObjectResolution/SingleObjectResolverBase.cs b/src/Umbraco.Core/ObjectResolution/SingleObjectResolverBase.cs
index 224467db6f..5d0e57c8f9 100644
--- a/src/Umbraco.Core/ObjectResolution/SingleObjectResolverBase.cs
+++ b/src/Umbraco.Core/ObjectResolution/SingleObjectResolverBase.cs
@@ -13,7 +13,7 @@ namespace Umbraco.Core.ObjectResolution
 	/// </remarks>
 	public abstract class SingleObjectResolverBase<TResolver, TResolved> : ResolverBase<TResolver>
 		where TResolved : class
-		where TResolver : class
+        where TResolver : ResolverBase
 	{
 		private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
 		private readonly bool _canBeNull;
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 7c1302648f..69ad1f60e6 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -206,6 +206,7 @@
     <Compile Include="Models\TaskType.cs" />
     <Compile Include="Models\Template.cs" />
     <Compile Include="ObjectResolution\ApplicationEventsResolver.cs" />
+    <Compile Include="ObjectResolution\ResolverCollection.cs" />
     <Compile Include="Persistence\Caching\InMemoryCacheProvider.cs" />
     <Compile Include="Persistence\Caching\IRepositoryCacheProvider.cs" />
     <Compile Include="Persistence\Caching\NullCacheProvider.cs" />
diff --git a/src/Umbraco.Tests/Resolvers/ResolutionTests.cs b/src/Umbraco.Tests/Resolvers/ResolutionTests.cs
index 2debaa1bd4..8e9da977a2 100644
--- a/src/Umbraco.Tests/Resolvers/ResolutionTests.cs
+++ b/src/Umbraco.Tests/Resolvers/ResolutionTests.cs
@@ -18,14 +18,14 @@ namespace Umbraco.Tests.Resolvers
         public void Setup()
         {
             TestHelper.SetupLog4NetForTests();
-
-            BaseResolver.Reset();
         }
 
         [TearDown]
         public void TearDown()
         {
             BaseResolver.Reset();
+            BaseResolver2.Reset();
+            BaseResolver3.Reset();
         }
 
         #region Resolvers and Resolved
@@ -33,6 +33,12 @@ namespace Umbraco.Tests.Resolvers
         class BaseResolver : ResolverBase<BaseResolver>
         { }
 
+        class BaseResolver2 : ResolverBase<BaseResolver2>
+        { }
+
+        class BaseResolver3 : ResolverBase<BaseResolver3>
+        { }
+
         #endregion
 
         #region Test Resolution
@@ -215,5 +221,45 @@ namespace Umbraco.Tests.Resolvers
         }
 
         #endregion
+
+        [Test]
+        public void Resolver_Collection_Is_Updated()
+        {
+            BaseResolver.Current = new BaseResolver();
+            BaseResolver2.Current = new BaseResolver2();
+            BaseResolver3.Current = new BaseResolver3();
+            Assert.AreEqual(3, ResolverCollection.Count);
+        }
+
+        [Test]
+        public void Resolver_Collection_Is_Reset()
+        {
+            BaseResolver.Current = new BaseResolver();
+            BaseResolver2.Current = new BaseResolver2();
+            BaseResolver3.Current = new BaseResolver3();
+            
+            ResolverCollection.ResetAll();
+
+            Assert.AreEqual(0, ResolverCollection.Count);
+            Assert.Throws<InvalidOperationException>(() =>
+                {
+                    var c = BaseResolver.Current;
+                });
+            Assert.Throws<InvalidOperationException>(() =>
+            {
+                var c = BaseResolver2.Current;
+            });
+            Assert.Throws<InvalidOperationException>(() =>
+            {
+                var c = BaseResolver3.Current;
+            });
+
+            //this should not error!
+            BaseResolver.Current = new BaseResolver();
+            BaseResolver2.Current = new BaseResolver2();
+            BaseResolver3.Current = new BaseResolver3();
+
+            Assert.Pass();
+        }
     }
 }