Makes ApplicationEventsResolver IDisposable so we can clear resources after startup.

src/Umbraco.Core/ObjectResolution/ApplicationEventsResolver.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using umbraco.interfaces;
 
 namespace Umbraco.Core.ObjectResolution
@@ -8,7 +9,10 @@ namespace Umbraco.Core.ObjectResolution
 	/// <summary>
 	/// A resolver to return all IApplicationEvents objects
 	/// </summary>
-    internal sealed class ApplicationEventsResolver : ManyObjectsResolverBase<ApplicationEventsResolver, IApplicationEventHandler>
+	/// <remarks>
+	/// This is disposable because after the app has started it should be disposed to release any memory being occupied by instances.
+	/// </remarks>
+    internal  sealed class ApplicationEventsResolver : ManyObjectsResolverBase<ApplicationEventsResolver, IApplicationEventHandler>, IDisposable
 	{
 
 	    private readonly LegacyStartupHandlerResolver _legacyResolver;
@@ -53,7 +57,7 @@ namespace Umbraco.Core.ObjectResolution
 
 		protected override bool SupportsClear
 		{
-			get { return false; }
+            get { return false; }
 		}		
 
 		protected override bool SupportsInsert
@@ -61,7 +65,7 @@ namespace Umbraco.Core.ObjectResolution
 			get { return false; }			
 		}
 
-	    private class LegacyStartupHandlerResolver : ManyObjectsResolverBase<ApplicationEventsResolver, IApplicationStartupHandler>
+	    private class LegacyStartupHandlerResolver : ManyObjectsResolverBase<ApplicationEventsResolver, IApplicationStartupHandler>, IDisposable
 	    {
 	        internal LegacyStartupHandlerResolver(IEnumerable<Type> legacyStartupHandlers)
                 : base(legacyStartupHandlers)
@@ -73,7 +77,72 @@ namespace Umbraco.Core.ObjectResolution
             {
                 get { return Values; }
             }
-	    }	    
 
+	        public void Dispose()
+	        {
+                Reset();
+	        }
+	    }
+
+	    private bool _disposed;
+		private readonly ReaderWriterLockSlim _disposalLocker = new ReaderWriterLockSlim();
+
+		/// <summary>
+		/// Gets a value indicating whether this instance is disposed.
+		/// </summary>
+		/// <value>
+		/// 	<c>true</c> if this instance is disposed; otherwise, <c>false</c>.
+		/// </value>
+		public bool IsDisposed
+		{
+			get { return _disposed; }
+		}
+
+		/// <summary>
+		/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+		/// </summary>
+		/// <filterpriority>2</filterpriority>
+		public void Dispose()
+		{
+			Dispose(true);
+
+			// Use SupressFinalize in case a subclass of this type implements a finalizer.
+			GC.SuppressFinalize(this);
+		}
+
+        ~ApplicationEventsResolver()
+		{
+			// Run dispose but let the class know it was due to the finalizer running.
+			Dispose(false);
+		}
+
+		private void Dispose(bool disposing)
+		{
+			// Only operate if we haven't already disposed
+			if (IsDisposed || disposing == false) return;
+
+			using (new WriteLock(_disposalLocker))
+			{
+				// Check again now we're inside the lock
+				if (IsDisposed) return;
+
+				// Call to actually release resources. This method is only
+				// kept separate so that the entire disposal logic can be used as a VS snippet
+				DisposeResources();
+
+				// Indicate that the instance has been disposed.
+				_disposed = true;
+			}
+		}
+
+	    /// <summary>
+	    /// Clear out all of the instances, we don't want them hanging around and cluttering up memory
+	    /// </summary>
+	    private void DisposeResources()
+	    {
+            _legacyResolver.Dispose();
+            Reset();
+	    }
+        
 	}
 }