Playing with CommonServiceLocator

SmallInjector/Container.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace SmallInjector
 {
@@ -8,13 +9,21 @@ namespace SmallInjector
     /// </summary>
     public class Container : IContainer
     {
-        private readonly Dictionary<Type, RegisteredType> _container = new Dictionary<Type, RegisteredType>();
+        private readonly Dictionary<Type, List<RegisteredType>> _container = new Dictionary<Type, List<RegisteredType>>();
 
         /// <inheritdoc/>
         public void RegisterType<TService, TInterface>(bool isSingleton, TService instance = default)
             where TService : TInterface
         {
-            _container.Add(typeof(TInterface), new RegisteredType(typeof(TService), isSingleton, null));
+            if (!IsRegistered<TService>())
+            {
+                _container[typeof(TInterface)] = new List<RegisteredType>
+                    {new RegisteredType(typeof(TService), isSingleton, null)};
+            }
+            else
+            {
+                _container[typeof(TInterface)].Add(new RegisteredType(typeof(TService), isSingleton, null));
+            }
         }
 
         /// <inheritdoc/>
@@ -30,26 +39,38 @@ namespace SmallInjector
         /// <inheritdoc />
         public bool IsRegistered(Type serviceType) => _container.ContainsKey(serviceType);
 
-        /// <inheritdoc/>
+        /// <inheritdoc />
-        public object Resolve(Type serviceInterface)
+        public IEnumerable<object> ResolveAny(Type serviceType)
         {
-            if (!_container.TryGetValue(serviceInterface, out var registeredType))
+            if (!_container.TryGetValue(serviceType, out var registeredTypes))
-                throw new Exception(@"Dependency {serviceInterface} is not registered");
+                throw new Exception(@"Dependency {serviceType} is not registered");
-
+            foreach (var registeredType in registeredTypes)
-            if (registeredType.IsSingleton && registeredType.Instance != null)
-                return registeredType.Instance;
-            var constructor = registeredType.ServiceType.GetConstructors()[0];
-            var parameters = constructor.GetParameters();
-            var constructorParameters = new object[parameters.Length];
-            for (var i = 0; i < parameters.Length; i++)
             {
-                constructorParameters[i] = Resolve(parameters[i].ParameterType);
+                if (registeredType.IsSingleton && registeredType.Instance != null)
-            }
+                {
+                    yield return registeredType.Instance;
+                    continue;
+                }
 
-            var instance = constructor.Invoke(constructorParameters);
+                var constructor = registeredType.ServiceType.GetConstructors()[0];
-            return registeredType.IsSingleton ? (registeredType.Instance = instance) : instance;
+                var parameters = constructor.GetParameters();
+                var constructorParameters = new object[parameters.Length];
+                for (var i = 0; i < parameters.Length; i++)
+                {
+                    constructorParameters[i] = Resolve(parameters[i].ParameterType);
+                }
+
+                var instance = constructor.Invoke(constructorParameters);
+                yield return registeredType.IsSingleton ? (registeredType.Instance = instance) : instance;
+            }
         }
 
+        /// <inheritdoc />
+        public IEnumerable<object> ResolveAny<TService>() => ResolveAny(typeof(TService));
+
+        /// <inheritdoc/>
+        public object Resolve(Type serviceType) => ResolveAny(serviceType).First();
+
         private class RegisteredType
         {
             public bool IsSingleton { get; }

SmallInjector/IContainer.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace SmallInjector
 {
@@ -24,7 +25,7 @@ namespace SmallInjector
         /// <summary>
         /// Resolve service of specified type.
         /// </summary>
-        object Resolve(Type serviceInterface);
+        object Resolve(Type serviceType);
 
         /// <summary>
         /// Resolve service of specified type.
@@ -40,5 +41,8 @@ namespace SmallInjector
         /// Returns true, if the service is registered. False otherwise.
         /// </summary>
         bool IsRegistered(Type serviceType);
+
+        IEnumerable<object> ResolveAny(Type serviceType);
+        IEnumerable<object> ResolveAny<TService>();
     }
 }

SmallInjector/ServiceLocatorWrapper.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+namespace SmallInjector
+{
+    /// <summary>
+    /// Wrapper for Service Locator
+    /// </summary>
+    public class ServiceLocatorWrapper : CommonServiceLocator.ServiceLocatorImplBase
+    {
+        private readonly IContainer _container;
+
+        /// <summary>
+        /// Creates new <see cref="ServiceLocatorWrapper"/> instance
+        /// </summary>
+        public ServiceLocatorWrapper(IContainer container)
+        {
+            _container = container;
+        }
+
+        /// <inheritdoc />
+        protected override object DoGetInstance(Type serviceType, string key) => _container.Resolve(serviceType);
+
+        /// <inheritdoc />
+        protected override IEnumerable<object> DoGetAllInstances(Type serviceType) => _container.ResolveAny(serviceType);
+    }
+}

SmallInjector/SmallInjector.csproj

@@ -12,4 +12,8 @@
     <DocumentationFile>C:\Users\Holger\Desktop\SmallInjectorDemo\SmallInjector\SmallInjector.xml</DocumentationFile>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="CommonServiceLocator" Version="2.0.4" />
+  </ItemGroup>
+
 </Project>

SmallInjectorDemo/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using CommonServiceLocator;
 using SmallInjector;
 
 namespace SmallInjectorDemo
@@ -7,8 +8,11 @@ namespace SmallInjectorDemo
     {
         private static void Main()
         {
-            Console.WriteLine("Small dependency injection example");
+
             IContainer container = new Container();
+            ServiceLocator.SetLocatorProvider(() => new ServiceLocatorWrapper(container));
+
+            Console.WriteLine("Small dependency injection example");
             container.RegisterType(true, container);
             Console.WriteLine("Register " + nameof(SystemClock));
             container.RegisterType<SystemClock, IClock>(true);
@@ -28,9 +32,12 @@ namespace SmallInjectorDemo
 
             Console.WriteLine();
             Console.WriteLine("Resolve class instances:");
-            var useful1 = container.Resolve<ServiceConsumer>();
+            //var useful1 = container.Resolve<ServiceConsumer>();
-            var useful2 = container.Resolve<ServiceConsumer>();
+            //var useful2 = container.Resolve<ServiceConsumer>();
-            var useful3 = container.Resolve<ServiceConsumer>();
+            //var useful3 = container.Resolve<ServiceConsumer>();
+            var useful1 = ServiceLocator.Current.GetInstance<ServiceConsumer>();
+            var useful2 = ServiceLocator.Current.GetInstance<ServiceConsumer>();
+            var useful3 = ServiceLocator.Current.GetInstance<ServiceConsumer>();
             Console.WriteLine();
             Console.WriteLine("Run test methods:");
             useful1.TestTheServices();

SmallInjectorDemo/SmallInjectorDemo.csproj

@@ -12,6 +12,9 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
     <DocumentationFile>bin\Release\netcoreapp2.1\SmallInjectorDemo.xml</DocumentationFile>
   </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="CommonServiceLocator" Version="2.0.4" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\SmallInjector\SmallInjector.csproj" />
   </ItemGroup>