diff --git a/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs b/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs
index a71d0a3f1e..0cd5705aa5 100644
--- a/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs
+++ b/src/Umbraco.Core/ObjectResolution/LazyManyObjectsResolverbase.cs
@@ -5,6 +5,19 @@ using System.Web;
 
 namespace Umbraco.Core.ObjectResolution
 {
+	/// <summary>
+	/// A base class for lazily resolving types for a resolver
+	/// </summary>
+	/// <typeparam name="TResolver"></typeparam>
+	/// <typeparam name="TResolved"></typeparam>
+	/// <remarks>
+	/// This is a special case resolver for when types get lazily resolved in order to resolve the actual types. This is useful
+	/// for when there is some processing overhead (i.e. Type finding in assemblies) to return the Types used to instantiate the instances. 
+	/// In some these cases we don't want to have to type find during application startup, only when we need to resolve the instances.
+	/// 
+	/// Important notes about this resolver: This does not support Insert or Remove and therefore does not support any ordering unless 
+	/// the types are marked with the WeightedPluginAttribute.
+	/// </remarks>
 	internal abstract class LazyManyObjectsResolverBase<TResolver, TResolved> : ManyObjectsResolverBase<TResolver, TResolved>
 		where TResolved : class
 		where TResolver : class
@@ -21,28 +34,62 @@ namespace Umbraco.Core.ObjectResolution
 		{
 		}
 
-		protected LazyManyObjectsResolverBase(IEnumerable<Lazy<Type>> value, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
+		/// <summary>
+		/// Constructor accepting a list of lazy types
+		/// </summary>
+		/// <param name="listOfLazyTypes"></param>
+		/// <param name="scope"></param>
+		protected LazyManyObjectsResolverBase(IEnumerable<Lazy<Type>> listOfLazyTypes, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
 			: this(scope)
 		{			
-			AddTypes(value);
+			AddTypes(listOfLazyTypes);
 		}
 
-		protected LazyManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable<Lazy<Type>> value)
+		/// <summary>
+		/// Constructor accepting a delegate to return a list of types
+		/// </summary>
+		/// <param name="typeListDelegate"></param>
+		/// <param name="scope"></param>
+		protected LazyManyObjectsResolverBase(Func<IEnumerable<Type>> typeListDelegate, ObjectLifetimeScope scope = ObjectLifetimeScope.Application)
+			: this(scope)
+		{
+			_listOfTypeListDelegates.Add(typeListDelegate);
+		}
+
+		/// <summary>
+		/// Constructor accepting a list of lazy types
+		/// </summary>
+		/// <param name="httpContext"></param>
+		/// <param name="listOfLazyTypes"></param>
+		protected LazyManyObjectsResolverBase(HttpContextBase httpContext, IEnumerable<Lazy<Type>> listOfLazyTypes)
 			: this(httpContext)
 		{
-			
+			AddTypes(listOfLazyTypes);
+		}
+
+		/// <summary>
+		/// Constructor accepting a delegate to return a list of types
+		/// </summary>
+		/// <param name="httpContext"></param>
+		/// <param name="typeListDelegate"></param>
+		protected LazyManyObjectsResolverBase(HttpContextBase httpContext, Func<IEnumerable<Type>> typeListDelegate)
+			: this(httpContext)
+		{
+			_listOfTypeListDelegates.Add(typeListDelegate);
 		} 
+
 		#endregion	
 
-		private readonly List<Lazy<Type>> _lazyTypes = new List<Lazy<Type>>();
-		private bool _hasResolvedTypes = false;
+		private readonly List<Lazy<Type>> _lazyTypeList = new List<Lazy<Type>>();
+		private readonly List<Func<IEnumerable<Type>>> _listOfTypeListDelegates = new List<Func<IEnumerable<Type>>>();
+		private List<Type> _resolvedTypes = null;
 		
 		/// <summary>
 		/// Used for unit tests
 		/// </summary>
 		internal bool HasResolvedTypes
 		{
-			get { return _hasResolvedTypes; }
+			get { return _resolvedTypes != null; }
 		}
 
 		/// <summary>
@@ -52,28 +99,50 @@ namespace Umbraco.Core.ObjectResolution
 		{
 			get
 			{
-				var list = _lazyTypes.Select(x => x.Value).ToArray();
-
-				//we need to validate each resolved type now since we could not do it before when inserting the lazy delegates
-				if (!_hasResolvedTypes)
+				using (var lck = GetUpgradeableReadLock())
 				{
-					var uniqueList = new List<Type>();					
-					foreach (var l in list)
-					{
-						EnsureCorrectType(l);
-						if (uniqueList.Contains(l))
-						{
-							throw new InvalidOperationException("The Type " + l + " already exists in the collection");
-						}
-						uniqueList.Add(l);
-					}
-					_hasResolvedTypes = true;
-				}
+					var lazyTypeList = _lazyTypeList.Select(x => x.Value).ToArray();
+					var listofTypeListDelegates = _listOfTypeListDelegates.SelectMany(x => x()).ToArray();
 
-				return list;
+					//we need to validate each resolved type now since we could not do it before when inserting the lazy delegates
+					if (!HasResolvedTypes)
+					{
+						lck.UpgradeToWriteLock();
+
+						_resolvedTypes = new List<Type>();
+
+						//first iterate the lazy type list
+						foreach (var l in lazyTypeList)
+						{
+							UpdateUniqueList(_resolvedTypes, l);
+						}
+
+						//next iterate the list of list type delegates
+						foreach (var l in listofTypeListDelegates)
+						{
+							UpdateUniqueList(_resolvedTypes, l);
+						}
+					}
+
+					return _resolvedTypes;	
+				}				
 			}
 		}
 
+		private void UpdateUniqueList(List<Type> uniqueList, Type toAdd)
+		{
+			EnsureCorrectType(toAdd);
+			if (uniqueList.Contains(toAdd))
+			{
+				throw new InvalidOperationException("The Type " + toAdd + " already exists in the collection");
+			}
+			uniqueList.Add(toAdd);
+		}
+
+		/// <summary>
+		/// Allows adding of multiple lazy types at once
+		/// </summary>
+		/// <param name="types"></param>
 		protected void AddTypes(IEnumerable<Lazy<Type>> types)
 		{
 			EnsureAddSupport();
@@ -84,11 +153,27 @@ namespace Umbraco.Core.ObjectResolution
 			{
 				foreach (var t in types)
 				{				
-					_lazyTypes.Add(t);
+					_lazyTypeList.Add(t);
 				}
 			}
 		}
 
+		/// <summary>
+		/// Adds a type list delegate to the collection
+		/// </summary>
+		/// <param name="typeListDelegate"></param>
+		public void AddTypeListDelegate(Func<IEnumerable<Type>> typeListDelegate)
+		{
+			EnsureAddSupport();
+
+			EnsureResolutionNotFrozen();
+
+			using (GetWriteLock())
+			{
+				_listOfTypeListDelegates.Add(typeListDelegate);
+			}
+		}
+
 		/// <summary>
 		/// Adds a lazy type to the list
 		/// </summary>
@@ -101,7 +186,7 @@ namespace Umbraco.Core.ObjectResolution
 
 			using (GetWriteLock())
 			{				
-				_lazyTypes.Add(value);
+				_lazyTypeList.Add(value);
 			}
 		}
 
@@ -125,7 +210,7 @@ namespace Umbraco.Core.ObjectResolution
 
 			using (GetWriteLock())
 			{
-				_lazyTypes.Clear();
+				_lazyTypeList.Clear();
 			}
 		}
 
diff --git a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs
index 9343b1a58b..c2fb584602 100644
--- a/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs
+++ b/src/Umbraco.Core/ObjectResolution/ManyObjectsResolverBase.cs
@@ -320,7 +320,16 @@ namespace Umbraco.Core.ObjectResolution
 		{
 			return new WriteLock(_lock);
 		}
-		
+
+		/// <summary>
+		/// Returns an upgradeable read lock for use when reading/modifying collections
+		/// </summary>
+		/// <returns></returns>
+		protected UpgradeableReadLock GetUpgradeableReadLock()
+		{
+			return new UpgradeableReadLock(_lock);
+		}
+
 		/// <summary>
 		/// Throws an exception if resolution is frozen
 		/// </summary>
diff --git a/src/Umbraco.Tests/Resolvers/LazyManyObjectResolverTests.cs b/src/Umbraco.Tests/Resolvers/LazyManyObjectResolverTests.cs
index 56ed107e68..977ddee355 100644
--- a/src/Umbraco.Tests/Resolvers/LazyManyObjectResolverTests.cs
+++ b/src/Umbraco.Tests/Resolvers/LazyManyObjectResolverTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
@@ -42,6 +43,58 @@ namespace Umbraco.Tests.Resolvers
 			Assert.IsTrue(instances1.Select(x => x.GetType()).ContainsAll(new []{typeof(TransientObject1), typeof(TransientObject2), typeof(TransientObject3)}));
 		}
 
+		[Test]
+		public void Type_List_Delegates_Combination()
+		{
+			Func<IEnumerable<Type>> types = () => new[] { typeof(TransientObject3), typeof(TransientObject2) };
+
+			var resolver = new LazyResolver(types);
+			resolver.AddTypeListDelegate(() => new[] { typeof(TransientObject1)});
+
+			Resolution.Freeze();
+
+			var instances1 = resolver.Objects;
+
+			Assert.AreEqual(3, instances1.Count());
+			Assert.IsTrue(instances1.Select(x => x.GetType()).ContainsAll(new[] { typeof(TransientObject1), typeof(TransientObject2), typeof(TransientObject3) }));
+		}
+
+		[Test]
+		public void Type_List_Delegates_And_Lazy_Type_Combination()
+		{
+			Func<IEnumerable<Type>> types = () => new[] { typeof(TransientObject3) };
+
+			var resolver = new LazyResolver(types);
+			resolver.AddType(new Lazy<Type>(() => typeof(TransientObject2)));
+			resolver.AddType<TransientObject1>();
+
+			Resolution.Freeze();
+
+			var instances1 = resolver.Objects;
+
+			Assert.AreEqual(3, instances1.Count());
+			Assert.IsTrue(instances1.Select(x => x.GetType()).ContainsAll(new[] { typeof(TransientObject1), typeof(TransientObject2), typeof(TransientObject3) }));
+		}
+
+		[Test]
+		public void Throws_If_Duplication()
+		{
+			Func<IEnumerable<Type>> types = () => new[] { typeof(TransientObject3), typeof(TransientObject2), typeof(TransientObject1) };
+
+			var resolver = new LazyResolver(types);
+			//duplicate, but will not throw here
+			resolver.AddType<TransientObject1>();
+
+			Resolution.Freeze();
+
+			Assert.Throws<InvalidOperationException>(() =>
+				{
+					var instances = resolver.Objects;
+				});
+
+
+		}
+
 		#region Test classes
 
 		private interface ITestInterface
@@ -73,6 +126,12 @@ namespace Umbraco.Tests.Resolvers
 				
 			}
 
+			public LazyResolver(Func<IEnumerable<Type>> typeList)
+				: base(typeList, ObjectLifetimeScope.Transient)
+			{
+
+			}
+
 			public IEnumerable<ITestInterface> Objects
 			{
 				get { return Values; }