Added MultipleResolverBase

src/Umbraco.Core/Resolving/MultipleResolverBase.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Umbraco.Core.Resolving
+{
+	/// <summary>
+	/// A Resolver to return and set a Multiply registered object.
+	/// </summary>
+	/// <typeparam name="TResolver"></typeparam>
+	/// <typeparam name="TResolved"></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 MultipleResolverBase<TResolver, TResolved> : ResolverBase<TResolver> 
+		where TResolver : class 
+		where TResolved : class
+	{
+		readonly List<TResolved> _resolved;
+		protected readonly ReaderWriterLockSlim Lock = new ReaderWriterLockSlim();
+
+		protected MultipleResolverBase()
+		{
+			_resolved = new List<TResolved>();
+		}
+
+		protected MultipleResolverBase(IEnumerable<TResolved> value)
+		{
+			_resolved = new List<TResolved>(value);
+		}		
+
+		protected IEnumerable<TResolved>  Values
+		{
+			get { return _resolved; }
+		}
+
+		public void Remove(TResolved item)
+		{
+			Resolution.EnsureNotFrozen();
+			using (new WriteLock(Lock))
+			{							
+				_resolved.Remove(item);
+			}
+		}
+
+		public void Add(TResolved item)
+		{
+			Resolution.EnsureNotFrozen();
+			using (new WriteLock(Lock))
+			{
+				_resolved.Add(item);			
+			}					
+		}
+
+		public void Clear()
+		{
+			Resolution.EnsureNotFrozen();
+			using (new WriteLock(Lock))
+			{
+				_resolved.Clear();
+			}			
+		}
+
+		public void Insert(int index, TResolved item)
+		{
+			Resolution.EnsureNotFrozen();
+			using (new WriteLock(Lock))
+			{
+				_resolved.Insert(index, item);
+			}	
+		}
+		
+	}
+}

src/Umbraco.Core/Resolving/SingleResolverBase.cs

@@ -2,6 +2,15 @@
 
 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 SingleResolverBase<TResolver, TResolved> : ResolverBase<TResolver> 
 		where TResolver : class 
 		where TResolved : class
@@ -30,6 +39,9 @@ namespace Umbraco.Core.Resolving
 			_canBeNull = canBeNull;
 		}
 
+		/// <summary>
+		/// Gets/sets the value of the object
+		/// </summary>
 		protected TResolved Value
 		{
 			get

src/Umbraco.Core/Umbraco.Core.csproj

@@ -50,6 +50,7 @@
     <Compile Include="LambdaExpressionCacheKey.cs" />
     <Compile Include="Resolving\ManyWeightedResolved.cs" />
     <Compile Include="Resolving\ManyWeightedResolverBase.cs" />
+    <Compile Include="Resolving\MultipleResolverBase.cs" />
     <Compile Include="Resolving\Resolution.cs" />
     <Compile Include="Resolving\ResolutionWeightAttribute.cs" />
     <Compile Include="Resolving\ResolverBase.cs" />

src/Umbraco.Tests/EnumerableExtensionsTests.cs

@@ -4,13 +4,33 @@ using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Tests;
 using umbraco.BusinessLogic;
+using Umbraco.Core.Resolving;
 
 namespace Umbraco.Tests
 {
+	[TestFixture]
+	public class MultipleResolverBaseTests
+	{
 
-	#region Used for benchmark test: Benchmark_Finding_First_Type_In_Assemblies
+		internal class MyItemsResolver : MultipleResolverBase<MyItemsResolver, object>
+		{
+			public MyItemsResolver(IEnumerable<object> initItems)
+			{
+				foreach(var i in initItems)
+				{
+					Add(i);
+				}
+			}
+
+			public IEnumerable<object> MyItems
+			{
+				get { return Values; }
+			}
+		}
+
+
+	}
 
-	#endregion
 
 	[TestFixture]
     public class EnumerableExtensionsTests