From bce183be4388fb2ea20d851e6a66183c5e517df2 Mon Sep 17 00:00:00 2001
From: hendryten <hendryten@yahoo.com>
Date: Wed, 25 Dec 2013 17:11:28 +0800
Subject: [PATCH] Add RegisterTo<TService, TTarget> method

Short hand for: Register<TService, TTarget>(factory =>
factory.GetInstance<TTarget>())
---
 LightInject.SampleLibrary/Foo.cs           | 12 ++++-
 LightInject.Tests/ServiceContainerTests.cs | 17 +++++++
 LightInject/LightInject.cs                 | 59 +++++++++++++++++++++-
 3 files changed, 86 insertions(+), 2 deletions(-)

diff --git a/LightInject.SampleLibrary/Foo.cs b/LightInject.SampleLibrary/Foo.cs
index dc751a3f..e980fb2e 100644
--- a/LightInject.SampleLibrary/Foo.cs
+++ b/LightInject.SampleLibrary/Foo.cs
@@ -25,13 +25,23 @@ public interface IFoo { }
     public class Foo : IFoo
     {
         public static int Instances { get; set; }
-        
+
         public Foo()
         {
             Instances++;
         }
     }
 
+    public class FooBar : IFoo, IBar
+    {
+        public static int Instances { get; set; }
+
+        public FooBar()
+        {
+            Instances++;
+        }
+    }
+
     public class FooWithStaticDependency : IFoo
     {
         public static IBar Bar { get; set; }
diff --git a/LightInject.Tests/ServiceContainerTests.cs b/LightInject.Tests/ServiceContainerTests.cs
index 34d9f93d..f296c9d2 100644
--- a/LightInject.Tests/ServiceContainerTests.cs
+++ b/LightInject.Tests/ServiceContainerTests.cs
@@ -424,6 +424,23 @@ public void GetInstance_DisposablePerRequestServiceOutsideScope_ThrowsException(
 
         }
 
+        [TestMethod]
+        public void GetInstance_RegisteredTo_PerScopeService_ReturnsSingleInstance()
+        {
+            var container = CreateContainer();
+            container.Register<FooBar>(new PerScopeLifetime());
+            container.RegisterTo<IFoo, FooBar>();
+            container.RegisterTo<IBar, FooBar>();
+            using (container.BeginScope())
+            {
+                var instanceFooBar = container.GetInstance<FooBar>();
+                var instance1 = container.GetInstance<IFoo>();
+                var instance2 = container.GetInstance<IBar>();
+
+                Assert.AreSame(instanceFooBar, instance2);
+                Assert.AreSame(instance1, instance2);
+            }
+        }
 
         #region Func Services
 
diff --git a/LightInject/LightInject.cs b/LightInject/LightInject.cs
index f2565baa..55fd8082 100644
--- a/LightInject/LightInject.cs
+++ b/LightInject/LightInject.cs
@@ -120,6 +120,30 @@ internal interface IServiceRegistry
         /// <param name="lifetime">The <see cref="ILifetime"/> instance that controls the lifetime of the registered service.</param>
         void Register<TService, TImplementation>(string serviceName, ILifetime lifetime) where TImplementation : TService;
 
+        /// <summary>
+        /// Registers the <typeparamref name="TService"/> to use the factory to get instance of <typeparamref name="TTarget"/>.
+        /// </summary>
+        /// <typeparam name="TService">The service type to register.</typeparam>
+        /// <typeparam name="TTarget">The target type.</typeparam>
+        void RegisterTo<TService, TTarget>() where TTarget : TService;
+
+        /// <summary>
+        /// Registers the <typeparamref name="TService"/> to use the factory to get instance of <typeparamref name="TTarget"/>.
+        /// </summary>
+        /// <typeparam name="TService">The service type to register.</typeparam>
+        /// <typeparam name="TTarget">The target type.</typeparam>
+        /// <param name="targetServiceName">The name of the service to be used for resolving.</param>
+        void RegisterTo<TService, TTarget>(string targetServiceName) where TTarget : TService;
+
+        /// <summary>
+        /// Registers the <typeparamref name="TService"/> to use the factory to get instance of <typeparamref name="TTarget"/>.
+        /// </summary>
+        /// <typeparam name="TService">The service type to register.</typeparam>
+        /// <typeparam name="TTarget">The target type.</typeparam>
+        /// <param name="targetServiceName">The name of the service to be used for resolving.</param>
+        /// <param name="serviceName">The name of the service.</param>
+        void RegisterTo<TService, TTarget>(string targetServiceName, string serviceName) where TTarget : TService;
+
         /// <summary>
         /// Registers the <typeparamref name="TService"/> with the given <paramref name="instance"/>. 
         /// </summary>
@@ -1431,7 +1455,7 @@ public void Register(ServiceRegistration serviceRegistration)
                 s => AddServiceRegistration(sr),
                 (k, existing) => UpdateServiceRegistration(existing, sr));            
         }
-      
+
         /// <summary>
         /// Registers services from the given <paramref name="assembly"/>.
         /// </summary>
@@ -1859,6 +1883,39 @@ public void Register(Type serviceType, Type implementingType)
             RegisterService(serviceType, implementingType, null, string.Empty);
         }
 
+        /// <summary>
+        /// Registers the <typeparamref name="TService"/> to use the factory to get instance of <typeparamref name="TTarget"/>.
+        /// </summary>
+        /// <typeparam name="TService">The service type to register.</typeparam>
+        /// <typeparam name="TTarget">The target type.</typeparam>
+        public void RegisterTo<TService, TTarget>() where TTarget : TService
+        {
+            Register<TService>(factory => factory.GetInstance<TTarget>());
+        }
+
+        /// <summary>
+        /// Registers the <typeparamref name="TService"/> to use the factory to get instance of <typeparamref name="TTarget"/>.
+        /// </summary>
+        /// <typeparam name="TService">The service type to register.</typeparam>
+        /// <typeparam name="TTarget">The target type.</typeparam>
+        /// <param name="targetServiceName">The name of the service to be used for resolving.</param>
+        public void RegisterTo<TService, TTarget>(string targetServiceName) where TTarget : TService
+        {
+            Register<TService>(factory => factory.GetInstance<TTarget>(targetServiceName));
+        }
+
+        /// <summary>
+        /// Registers the <typeparamref name="TService"/> to use the factory to get instance of <typeparamref name="TTarget"/>.
+        /// </summary>
+        /// <typeparam name="TService">The service type to register.</typeparam>
+        /// <typeparam name="TTarget">The target type.</typeparam>
+        /// <param name="targetServiceName">The name of the service to be used for resolving.</param>
+        /// <param name="serviceName">The name of the service.</param>
+        public void RegisterTo<TService, TTarget>(string targetServiceName, string serviceName) where TTarget : TService
+        {
+            Register<TService>(factory => factory.GetInstance<TTarget>(targetServiceName), serviceName);
+        }
+
         /// <summary>
         /// Gets an instance of the given <paramref name="serviceType"/>.
         /// </summary>