Merge pull request #1 from servicetitan/proxy-improvements

Proxy improvements

Author: hypercodeplace

LazyProxy.Unity.Tests/UnityExtensionTests.cs

@@ -161,8 +161,8 @@ public void LifetimeMustBeCorrect()
             _service2Id = string.Empty;
 
             var container = new UnityContainer()
-                .RegisterLazy<IService1, Service1>(() => new SingletonLifetimeManager())
-                .RegisterLazy<IService2, Service2>(() => new SingletonLifetimeManager());
+                .RegisterLazy<IService1, Service1>(() => new ContainerControlledLifetimeManager())
+                .RegisterLazy<IService2, Service2>(() => new ContainerControlledLifetimeManager());
 
             Assert.Empty(_service1Id);
             Assert.Empty(_service2Id);
@@ -222,5 +222,64 @@ public void ServicesMustBeResolvedFromChildContainer()
 
             Assert.Null(exception);
         }
+
+        [Fact]
+        public void ServicesMustBeResolvedByNameWithCorrectLifetime()
+        {
+            const string serviceName1 = "serviceName1";
+            const string serviceName2 = "serviceName2";
+
+            var container = new UnityContainer()
+                .RegisterLazy<IService1, Service1>(serviceName1, () => new ContainerControlledLifetimeManager())
+                .RegisterLazy<IService1, Service1>(serviceName2, () => new HierarchicalLifetimeManager());
+
+            var childContainer = container.CreateChildContainer();
+
+            Assert.Throws<ResolutionFailedException>(() => container.Resolve<IService1>());
+            Assert.Same(container.Resolve<IService1>(serviceName1), container.Resolve<IService1>(serviceName1));
+            Assert.Same(container.Resolve<IService1>(serviceName2), container.Resolve<IService1>(serviceName2));
+            Assert.NotSame(container.Resolve<IService1>(serviceName1), container.Resolve<IService1>(serviceName2));
+
+            Assert.Throws<ResolutionFailedException>(() => childContainer.Resolve<IService1>());
+            Assert.Same(childContainer.Resolve<IService1>(serviceName1), childContainer.Resolve<IService1>(serviceName1));
+            Assert.Same(childContainer.Resolve<IService1>(serviceName2), childContainer.Resolve<IService1>(serviceName2));
+
+            Assert.NotSame(childContainer.Resolve<IService1>(serviceName1), childContainer.Resolve<IService1>(serviceName2));
+            Assert.Same(container.Resolve<IService1>(serviceName1), childContainer.Resolve<IService1>(serviceName1));
+            Assert.NotSame(container.Resolve<IService1>(serviceName2), childContainer.Resolve<IService1>(serviceName2));
+        }
+
+        [Fact]
+        public void ServicesMustBeResolvedByNameWithCorrectInjectionMembers()
+        {
+            const string arg = "arg";
+            const string result1 = "result1";
+            const string result2 = "result2";
+            const string serviceName1 = "serviceName1";
+            const string serviceName2 = "serviceName2";
+
+            var serviceMock1 = new Mock<IService2>(MockBehavior.Strict);
+            serviceMock1.Setup(s => s.Method(arg)).Returns(result1);
+
+            var serviceMock2 = new Mock<IService2>(MockBehavior.Strict);
+            serviceMock2.Setup(s => s.Method(arg)).Returns(result2);
+
+            var container = new UnityContainer()
+                .RegisterLazy<IService1, Service1>(serviceName1, new InjectionConstructor(serviceMock1.Object))
+                .RegisterLazy<IService1, Service1>(serviceName2, new InjectionConstructor(serviceMock2.Object));
+
+            var actualResult1 = container.Resolve<IService1>(serviceName1).MethodWithOtherServiceInvocation(arg);
+            var actualResult2 = container.Resolve<IService1>(serviceName2).MethodWithOtherServiceInvocation(arg);
+
+            Assert.Throws<ResolutionFailedException>(() => container.Resolve<IService1>());
+            Assert.Equal("service1->" + result1, actualResult1);
+            Assert.Equal("service1->" + result2, actualResult2);
+        }
+
+        [Fact]
+        public void RegistrationMustThrowAnExceptionForNonInterfaces()
+        {
+            Assert.Throws<NotSupportedException>(() => new UnityContainer().RegisterLazy<Service1, Service1>());
+        }
     }
 }

LazyProxy.Unity/LazyProxy.Unity.csproj

@@ -15,7 +15,7 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="LazyProxy" Version="0.1.0" />
+    <PackageReference Include="LazyProxy" Version="0.1.1" />
     <PackageReference Include="Unity" Version="5.8.6" />
   </ItemGroup>
 </Project>

LazyProxy.Unity/UnityExtensions.cs

@@ -8,6 +8,8 @@ namespace LazyProxy.Unity
 {
     public static class UnityExtensions
     {
+        private static readonly Func<LifetimeManager> GetTransientLifetimeManager = () => new TransientLifetimeManager();
+
         /// <summary>
         /// Is used to register interface TFrom to class TTo by creation a lazy proxy at runtime.
         /// The real class To will be instantiated only after first method execution.
@@ -19,10 +21,24 @@ public static class UnityExtensions
         /// <returns>The instance of Unity container.</returns>
         public static IUnityContainer RegisterLazy<TFrom, TTo>(this IUnityContainer container,
             params InjectionMember[] injectionMembers)
-            where TTo : TFrom where TFrom : class
-        {
-            return container.RegisterLazy<TFrom, TTo>(() => new TransientLifetimeManager(), injectionMembers);
-        }
+            where TTo : TFrom where TFrom : class =>
+            container.RegisterLazy<TFrom, TTo>(null, GetTransientLifetimeManager, injectionMembers);
+
+        /// <summary>
+        /// Is used to register interface TFrom to class TTo by creation a lazy proxy at runtime.
+        /// The real class To will be instantiated only after first method or property execution.
+        /// </summary>
+        /// <param name="container">The instance of Unity container.</param>
+        /// <param name="name">The registration name.</param>
+        /// <param name="injectionMembers">The set of injection members.</param>
+        /// <typeparam name="TFrom">The binded interface.</typeparam>
+        /// <typeparam name="TTo">The binded class.</typeparam>
+        /// <returns>The instance of Unity container.</returns>
+        public static IUnityContainer RegisterLazy<TFrom, TTo>(this IUnityContainer container,
+            string name,
+            params InjectionMember[] injectionMembers)
+            where TTo : TFrom where TFrom : class =>
+            container.RegisterLazy<TFrom, TTo>(name, GetTransientLifetimeManager, injectionMembers);
 
         /// <summary>
         /// Is used to register interface TFrom to class TTo by creation a lazy proxy at runtime.
@@ -35,16 +51,40 @@ public static IUnityContainer RegisterLazy<TFrom, TTo>(this IUnityContainer cont
         /// <typeparam name="TTo">The binded class.</typeparam>
         /// <returns>The instance of Unity container.</returns>
         public static IUnityContainer RegisterLazy<TFrom, TTo>(this IUnityContainer container,
+            Func<LifetimeManager> getLifetimeManager,
+            params InjectionMember[] injectionMembers)
+            where TTo : TFrom where TFrom : class =>
+            container.RegisterLazy<TFrom, TTo>(null, getLifetimeManager, injectionMembers);
+
+        /// <summary>
+        /// Is used to register interface TFrom to class TTo by creation a lazy proxy at runtime.
+        /// The real class To will be instantiated only after first method or property execution.
+        /// </summary>
+        /// <param name="container">The instance of Unity container.</param>
+        /// <param name="name">The registration name.</param>
+        /// <param name="getLifetimeManager">The function instance lifetime provides.</param>
+        /// <param name="injectionMembers">The set of injection members.</param>
+        /// <typeparam name="TFrom">The binded interface.</typeparam>
+        /// <typeparam name="TTo">The binded class.</typeparam>
+        /// <returns>The instance of Unity container.</returns>
+        public static IUnityContainer RegisterLazy<TFrom, TTo>(this IUnityContainer container,
+            string name,
             Func<LifetimeManager> getLifetimeManager,
             params InjectionMember[] injectionMembers)
             where TTo : TFrom where TFrom : class
         {
+            // There is no way to constraint it on the compilation step.
+            if (!typeof(TFrom).IsInterface)
+            {
+                throw new NotSupportedException("The lazy registration is supported only for interfaces.");
+            }
+
             var lazyProxyType = LazyProxyBuilder.BuildLazyProxyType<TFrom>();
             var registrationName = Guid.NewGuid().ToString();
 
             return container
                 .RegisterType<TFrom, TTo>(registrationName, getLifetimeManager(), injectionMembers)
-                .RegisterType(typeof(TFrom), lazyProxyType,
+                .RegisterType(typeof(TFrom), lazyProxyType, name,
                     getLifetimeManager(),
                     new InjectionConstructor(
                         new ResolvedParameter<Lazy<TFrom>>(registrationName))