thedersen · bendup · May 5, 2016 · May 9, 2016
diff --git a/README.md b/README.md
@@ -1,4 +1,4 @@
-# UnityConfiguration v1.4.1
+# UnityConfiguration v1.4.2
 
 Convention based configuration for the Microsoft Unity IoC container. With just a few lines of code, you can now registere all your classes in the entire solution. If the built-in conventions doesn't fit your needs, it is very easy to extend with your own.
 
@@ -86,6 +86,9 @@ At the moment, built in conventions includes AddAllConvention, FirstInterfaceCon
 
 ## Release Notes
 
+#### v1.4.2
+* Added support for registering concrete instance against interface
+
 #### v1.4.1
 * Fixed #6: AssemblyScanner not bin folder friendly for web apps
 * Added #5: `IUnityContainer.Configure()` returns the `IUnityContainer` so other calls can be chained

diff --git a/src/UnityConfiguration.Tests/TypeRegistrationTests.cs b/src/UnityConfiguration.Tests/TypeRegistrationTests.cs
@@ -80,5 +80,16 @@ public void Can_register_using_factory_delegate()
 
             Assert.That(container.Resolve<IBarService>(), Is.SameAs(myService));
         }
+
+        [Test]
+        public void Can_register_using_object_instance()
+        {
+            var container = new UnityContainer();
+
+            var myService = new BarService();
+            container.Configure(x => x.Register<IBarService>(myService));
+
+            Assert.That(container.Resolve<IBarService>(), Is.SameAs(myService));
+        }
     }
 }
diff --git a/src/UnityConfiguration.Tests/UnityConfiguration.Tests.csproj b/src/UnityConfiguration.Tests/UnityConfiguration.Tests.csproj
@@ -118,9 +118,7 @@
     <Compile Include="TypeRegistrationTests.cs" />
     <Compile Include="UnityExtensionsConfigurationTests.cs" />
     <Compile Include="UserInterface\IMyView.cs" />
-    <Compile Include="UserInterface\MyView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
+    <Compile Include="UserInterface\MyView.cs" />
     <Compile Include="UserInterface\MyView.Designer.cs">
       <DependentUpon>MyView.cs</DependentUpon>
     </Compile>

diff --git a/src/UnityConfiguration.sln b/src/UnityConfiguration.sln
@@ -1,6 +1,8 @@
 
-Microsoft Visual Studio Solution File, Format Version 11.00
-# Visual Studio 2010
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25123.0
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnityConfiguration", "UnityConfiguration\UnityConfiguration.csproj", "{D5FD47DA-D607-46DC-895E-2C823905D147}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnityConfiguration.Tests", "UnityConfiguration.Tests\UnityConfiguration.Tests.csproj", "{337E95CC-230A-4DAC-86BE-F26998402B42}"

diff --git a/src/UnityConfiguration/IUnityRegistry.cs b/src/UnityConfiguration/IUnityRegistry.cs
@@ -24,6 +24,28 @@ public interface IUnityRegistry : IHideObjectMembers
         /// <param name="registry">An instance of the <see cref="UnityRegistry"/> to import.</param>
         void AddRegistry(UnityRegistry registry);
 
+        /// <summary>
+        /// Register a type mapping in the container by using a concrete instance.
+        /// </summary>
+        /// <param name="typeFrom">The type that will be requested.</param>
+        /// <param name="instanceTo">The instance that will be returned.</param>
+        /// <returns>
+        /// An instance of a <see cref="RegistrationExpression"/> that can be used to 
+        /// further configure the registration.
+        /// </returns>
+        RegistrationExpression Register(Type typeFrom,object instanceTo);
+
+        /// <summary>
+        /// Register a type mapping in the container by using a concrete instance.
+        /// </summary>
+        /// <typeparam name="tFrom">The type that will be requested.</typeparam>
+        /// <param name="instanceTo">The instance that will be returned.</param>
+        /// <returns>
+        /// An instance of a <see cref="RegistrationExpression"/> that can be used to 
+        /// further configure the registration.
+        /// </returns>
+        RegistrationExpression Register<tFrom>(object instanceTo) ;
+
         /// <summary>
         /// Register a type mapping in the container.
         /// </summary>

diff --git a/src/UnityConfiguration/InstanceBasedRegistrationExpression.cs b/src/UnityConfiguration/InstanceBasedRegistrationExpression.cs
@@ -0,0 +1,22 @@
+using System;
+using Microsoft.Practices.Unity;
+
+namespace UnityConfiguration
+{
+    public class InstanceBasedRegistrationExpression : RegistrationExpression
+    {
+        private object instanceTo;
+
+        public InstanceBasedRegistrationExpression(Type typeFrom, object instanceTo)
+            :base (typeFrom,null)
+        {
+            lifetimeManagerFunc = () => new ContainerControlledLifetimeManager();
+            this.instanceTo = instanceTo;
+        }
+
+        internal override void Execute(IUnityContainer container)
+        {
+            container.RegisterInstance(typeFrom, name, instanceTo,  lifetimeManagerFunc());
+        }
+    }
+}
diff --git a/src/UnityConfiguration/Properties/AssemblyInfo.cs b/src/UnityConfiguration/Properties/AssemblyInfo.cs
@@ -2,9 +2,9 @@
 using System.Runtime.InteropServices;
 [assembly: AssemblyTitle("UnityConfiguration")]
 [assembly: AssemblyDescription("Convention based configuration API for the Microsoft Unity IoC container. With just a few lines of code, you can now registere all your classes in the entire solution. If the built-in conventions doesn't fit your needs, it is very easy to extend with your own.")]
-[assembly: AssemblyCompany("UnityConfiguration")]
+[assembly: AssemblyCompany("Thomas Pedersen")]
 [assembly: AssemblyProduct("UnityConfiguration")]
 [assembly: AssemblyCopyright("Copyright (C) 2011 Thomas Pedersen")]
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("1.4.1")]
+[assembly: AssemblyVersion("1.4.2")]
 
diff --git a/src/UnityConfiguration/RegistrationExpression.cs b/src/UnityConfiguration/RegistrationExpression.cs
@@ -1,61 +1,61 @@
-using System;
-using Microsoft.Practices.Unity;
-
-namespace UnityConfiguration
-{
-    public class RegistrationExpression : Expression, INamedRegistrationExpression
-    {
-        private readonly Type typeFrom;
-        private Type typeTo;
-        private InjectionMember[] injectionMembers;
-        private Func<LifetimeManager> lifetimeManagerFunc;
-        private string name;
-        
-        public RegistrationExpression(Type typeFrom, Type typeTo)
-        {
-            this.typeFrom = typeFrom;
-            this.typeTo = typeTo;
-            lifetimeManagerFunc = () => new TransientLifetimeManager();
-            injectionMembers = new InjectionMember[0];
-        }
-
-        public IRegistrationExpression WithName(string name)
-        {
-            this.name = name;
-            return this;
-        }
-
-        public ILifetimePolicyExpression WithConstructorArguments(params object[] args)
-        {
-            WithInjectionMembers(new InjectionConstructor(args));
-            return this;
-        }
-
-        public void Using<T>() where T : LifetimeManager, new()
-        {
-            lifetimeManagerFunc = () => new T();
-        }
-
-        internal void WithInjectionMembers(params InjectionMember[] injectionMember)
-        {
-            injectionMembers = injectionMember;
-        }
-
-        internal override void Execute(IUnityContainer container)
-        {
-            if (typeFrom == null && !typeTo.IsConcrete())
-            {
-                container.Registrations.ForEach(c =>
-                {
-                    if (c.RegisteredType == typeTo)
-                        container.RegisterType(c.MappedToType, c.Name, lifetimeManagerFunc(), injectionMembers);
-
-                });
-            }
-            else
-            {
-                container.RegisterType(typeFrom, typeTo, name, lifetimeManagerFunc(), injectionMembers);
-            }
-        }
-    }
+using System;
+using Microsoft.Practices.Unity;
+
+namespace UnityConfiguration
+{
+    public class RegistrationExpression : Expression, INamedRegistrationExpression
+    {
+        protected readonly Type typeFrom;
+        private Type typeTo;
+        private InjectionMember[] injectionMembers;
+        protected Func<LifetimeManager> lifetimeManagerFunc;
+        protected string name;
+
+        public RegistrationExpression(Type typeFrom, Type typeTo)
+        {
+            this.typeFrom = typeFrom;
+            this.typeTo = typeTo;
+            lifetimeManagerFunc = () => new TransientLifetimeManager();
+            injectionMembers = new InjectionMember[0];
+        }
+
+        public IRegistrationExpression WithName(string name)
+        {
+            this.name = name;
+            return this;
+        }
+
+        public ILifetimePolicyExpression WithConstructorArguments(params object[] args)
+        {
+            WithInjectionMembers(new InjectionConstructor(args));
+            return this;
+        }
+
+        public void Using<T>() where T : LifetimeManager, new()
+        {
+            lifetimeManagerFunc = () => new T();
+        }
+
+        internal void WithInjectionMembers(params InjectionMember[] injectionMember)
+        {
+            injectionMembers = injectionMember;
+        }
+
+        internal override void Execute(IUnityContainer container)
+        {
+            if (typeFrom == null && !typeTo.IsConcrete())
+            {
+                container.Registrations.ForEach(c =>
+                {
+                    if (c.RegisteredType == typeTo)
+                        container.RegisterType(c.MappedToType, c.Name, lifetimeManagerFunc(), injectionMembers);
+
+                });
+            }
+            else
+            {
+                container.RegisterType(typeFrom, typeTo, name, lifetimeManagerFunc(), injectionMembers);
+            }
+        }
+    }
 }
diff --git a/src/UnityConfiguration/UnityConfiguration.csproj b/src/UnityConfiguration/UnityConfiguration.csproj
@@ -65,6 +65,7 @@
     <Compile Include="ConfigureExtensionExpression.cs" />
     <Compile Include="ConventionExtensions.cs" />
     <Compile Include="IHideObjectMembers.cs" />
+    <Compile Include="InstanceBasedRegistrationExpression.cs" />
     <Compile Include="IRegistrationExpression.cs" />
     <Compile Include="LifetimeExtensions.cs" />
     <Compile Include="NamingConvention.cs" />

diff --git a/src/UnityConfiguration/UnityRegistry.cs b/src/UnityConfiguration/UnityRegistry.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Runtime.InteropServices;
 using Microsoft.Practices.Unity;
 
 namespace UnityConfiguration
@@ -31,6 +32,18 @@ public void AddRegistry(UnityRegistry registry)
             registries.Add(registry);
         }
 
+        public RegistrationExpression Register(Type typeFrom, object instanceTo)
+        {
+            var registrationExpression = new InstanceBasedRegistrationExpression(typeFrom, instanceTo);
+            registrations.Add(registrationExpression);
+            return registrationExpression;
+        }
+
+        public RegistrationExpression Register<tFrom>(object instanceTo)
+        {
+            return Register(typeof(tFrom),instanceTo);
+        }
+
         public RegistrationExpression Register(Type typeFrom, Type typeTo)
         {
             var registrationExpression = new RegistrationExpression(typeFrom, typeTo);