(#4) Removed all references to possible multiple registrations

Author: nils-a

src/Spectre.Console.Registrars.SimpleInjector.Tests/RegistrarFixture.cs

@@ -12,18 +12,12 @@ internal class RegistrarFixture
         private readonly List<Action<Container>> containerActions = new List<Action<Container>>();
         private readonly List<Action<ITypeRegistrar>> registrarActions = new List<Action<ITypeRegistrar>>();
         private Lifestyle lifestyle;
-        private Type[] multiRegistrationTypes;
 
         internal void GivenLifestyle(Lifestyle lifestyle)
         {
             this.lifestyle = lifestyle;
         }
 
-        internal void GivenMultiRegistrationTypes(params Type[] multiRegistrationTypes)
-        {
-            this.multiRegistrationTypes = multiRegistrationTypes;
-        }
-
         internal void GivenOnContainer(Action<Container> action)
         {
             containerActions.Add(action);
@@ -42,7 +36,7 @@ internal ITypeResolver GetResolver()
                 action(container);
             }
 
-            var registrar = new SimpleInjectorRegistrar(container, lifestyle, multiRegistrationTypes);
+            var registrar = new SimpleInjectorRegistrar(container, lifestyle);
             foreach (var action in registrarActions)
             {
                 action(registrar);

src/Spectre.Console.Registrars.SimpleInjector.Tests/RegistrarTests.cs

@@ -69,20 +69,6 @@ public void Resolver_Should_Return_Lazy_From_Registrar()
             ReferenceEquals(expected, actual).ShouldBeTrue();
         }
 
-        [Fact]
-        public void Resolver_Resolving_From_Multiple_Lazies_Returns_The_Last_Registration()
-        {
-            var fixture = new RegistrarFixture();
-            fixture.GivenMultiRegistrationTypes(typeof(ISomeInterface));
-            fixture.GivenOnRegistrar(r => r.RegisterLazy(typeof(ISomeInterface), () => new SomeDependency()));
-            fixture.GivenOnRegistrar(r => r.RegisterLazy(typeof(ISomeInterface), () => new SomeOtherDependency()));
-
-            var actual = fixture.GetResolver().Resolve(typeof(ISomeInterface));
-
-            actual.ShouldNotBeNull();
-            actual.ShouldBeOfType<SomeOtherDependency>();
-        }
-
         [Fact(Skip = "Doesn't work at the moment")]
         public void Resolver_Should_Not_Call_Lazy_Factory_If_Not_Needed()
         {
@@ -99,57 +85,12 @@ public void Resolver_Should_Not_Call_Lazy_Factory_If_Not_Needed()
             factoryCalled.ShouldBeFalse();
         }
 
-        [Fact]
-        public void Resolver_Registering_Multiple_Does_Not_Throw()
-        {
-            var fixture = new RegistrarFixture();
-            fixture.GivenMultiRegistrationTypes(typeof(ISomeInterface));
-            fixture.GivenOnRegistrar(r => r.Register(typeof(ISomeInterface), typeof(SomeDependency)));
-            fixture.GivenOnRegistrar(r => r.Register(typeof(ISomeInterface), typeof(SomeOtherDependency)));
-
-            var actual = fixture.GetResolver().Resolve(typeof(ISomeInterface));
-
-            actual.ShouldNotBeNull();
-        }
-
-        [Fact]
-        public void Resolver_Resolving_From_Multiple_Returns_The_Last_Registration()
-        {
-            var fixture = new RegistrarFixture();
-            fixture.GivenMultiRegistrationTypes(typeof(ISomeInterface));
-            fixture.GivenOnRegistrar(r => r.Register(typeof(ISomeInterface), typeof(SomeDependency)));
-            fixture.GivenOnRegistrar(r => r.Register(typeof(ISomeInterface), typeof(SomeOtherDependency)));
-
-            var actual = fixture.GetResolver().Resolve(typeof(ISomeInterface));
-
-            actual.ShouldNotBeNull();
-            actual.ShouldBeOfType<SomeOtherDependency>();
-        }
-
-        [Fact]
-        public void Resolver_Resolving_From_Multiple_Instances_Returns_The_Last_Registration()
-        {
-            var fixture = new RegistrarFixture();
-            fixture.GivenMultiRegistrationTypes(typeof(ISomeInterface));
-            fixture.GivenOnRegistrar(r => r.RegisterInstance(typeof(ISomeInterface), new SomeDependency()));
-            fixture.GivenOnRegistrar(r => r.RegisterInstance(typeof(ISomeInterface), new SomeOtherDependency()));
-
-            var actual = fixture.GetResolver().Resolve(typeof(ISomeInterface));
-
-            actual.ShouldNotBeNull();
-            actual.ShouldBeOfType<SomeOtherDependency>();
-        }
-
         private interface ISomeInterface
         {
         }
 
         private class SomeDependency : ISomeInterface
         {
         }
-
-        private class SomeOtherDependency : ISomeInterface
-        {
-        }
     }
 }

src/Spectre.Console.Registrars.SimpleInjector/SimlpeInjectorRegistrar.cs

@@ -1,9 +1,7 @@
 using System;
-using System.Linq;
 using SimpleInjector;
 using Spectre.Console.Cli;
 
-// ReSharper disable once CheckNamespace
 namespace Spectre.Console
 {
     /// <summary>
@@ -13,90 +11,53 @@ public class SimpleInjectorRegistrar : ITypeRegistrar
     {
         private readonly Container container;
         private readonly Lifestyle lifestyle;
-        private readonly Type[] multiRegistrationTypes;
 
         /// <summary>
         /// Constructs a new instance using the the given <see cref="Container" />.
-        /// <para>
-        /// Since SimpleInjector inherently
-        /// <see href="https://docs.simpleinjector.org/en/latest/decisions.html#separate-collections">differentiates
-        /// the registration of collections from registering a single implementation</see> the types that are to be
-        /// registered as collections need to be known before registering them. A list of types that are registered
-        /// as collections can be set using the <paramref name="multiRegistrationTypes"/> param.
-        /// </para>
         /// </summary>
         /// <param name="container">The <see cref="Container"/> to build the <see cref="ITypeRegistrar"/> around.</param>
         /// <param name="lifestyle">The <see cref="Lifestyle"/> to use during registrations. Default is <see cref="Lifestyle.Singleton"/>.</param>
-        /// <param name="multiRegistrationTypes">List of types that are to be registered multiple times.
-        /// Default is [ <see cref="ICommand{TSettings}"/>, <see cref="ICommand"/> ].</param>
         /// <exception cref="ArgumentNullException"></exception>
         public SimpleInjectorRegistrar(Container container,
-            Lifestyle lifestyle = null,
-            Type[] multiRegistrationTypes = null)
+            Lifestyle lifestyle = null)
         {
             this.container = container ?? throw new ArgumentNullException(nameof(container));
             this.lifestyle = lifestyle ?? Lifestyle.Singleton;
-            this.multiRegistrationTypes = multiRegistrationTypes ?? new[]
-            {
-                typeof(ICommand),
-                typeof(ICommand<>)
-            };
         }
 
         /// <inheritdoc cref="ITypeRegistrar.Register"/>
         public void Register(Type service, Type implementation)
         {
-            if (multiRegistrationTypes.Contains(service))
-            {
-                container.Collection.Append(service, implementation, lifestyle);
-                return;
-            }
-
             container.Register(service, implementation, lifestyle);
         }
 
         /// <inheritdoc cref="ITypeRegistrar.RegisterInstance"/>
         public void RegisterInstance(Type service, object implementation)
         {
-            if (multiRegistrationTypes.Contains(service))
-            {
-                container.Collection.AppendInstance(service, implementation);
-                return;
-            }
-
             container.RegisterInstance(service, implementation);
         }
 
         /// <inheritdoc cref="ITypeRegistrar.RegisterLazy"/>
         public void RegisterLazy(Type service, Func<object> factory)
         {
             // todo: non of these code-paths are lazy!!
-            if (multiRegistrationTypes.Contains(service))
-            {
-                var registration = lifestyle.CreateRegistration(service, factory, container);
-                container.Collection.Append(service, registration);
-                return;
-            }
-
             container.Register(service, factory, lifestyle);
         }
 
         /// <inheritdoc cref="ITypeRegistrar.Build"/>
         public ITypeResolver Build()
         {
             container.Verify();
-            return new SimpleInjectorTypeResolver(container, multiRegistrationTypes);
+            return new SimpleInjectorTypeResolver(container);
         }
 
         private class SimpleInjectorTypeResolver : ITypeResolver
         {
             private readonly Container container;
-            private readonly Type[] multiRegistrationTypes;
 
-            public SimpleInjectorTypeResolver(Container container, Type[] multiRegistrationTypes)
+            public SimpleInjectorTypeResolver(Container container)
             {
                 this.container = container;
-                this.multiRegistrationTypes = multiRegistrationTypes;
             }
 
             public object Resolve(Type type)
@@ -106,9 +67,7 @@ public object Resolve(Type type)
                     throw new ArgumentNullException(nameof(type));
                 }
 
-                var implementation = multiRegistrationTypes.Contains(type)
-                    ? container.GetAllInstances(type).LastOrDefault()
-                    : container.GetInstance(type);
+                var implementation = container.GetInstance(type);
 
                 return implementation;
             }

src/Spectre.Console.Registrars.SimpleInjector/Spectre.Console.Registrars.SimpleInjector.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net5.0;net6.0</TargetFrameworks>
+    <RootNamespace>Spectre.Console</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>