Merge pull request #7 from servicetitan/migrate-to-unity-5-10

Migrate to UnityContainer v5.10.2

Author: hypercodeplace

LazyProxy.Unity.Sample/LazyProxy.Unity.Sample.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>netcoreapp2.0</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Unity" Version="5.8.13" />
+    <PackageReference Include="Unity" Version="5.10.2" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\LazyProxy.Unity\LazyProxy.Unity.csproj" />

LazyProxy.Unity.Tests/UnityExtensionTests.cs

@@ -2,12 +2,11 @@
 using System.Runtime.CompilerServices;
 using Moq;
 using Unity;
-using Unity.Exceptions;
 using Unity.Injection;
 using Unity.Lifetime;
 using Unity.Resolution;
 using Xunit;
-using DependencyAttribute = Unity.Attributes.DependencyAttribute;
+using DependencyAttribute = Unity.DependencyAttribute;
 
 [assembly: InternalsVisibleTo("LazyProxy.DynamicTypes")]
 

LazyProxy.Unity/LazyProxy.Unity.csproj

@@ -16,6 +16,6 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="LazyProxy" Version="0.1.4" />
-    <PackageReference Include="Unity" Version="5.8.13" />
+    <PackageReference Include="Unity" Version="5.10.2" />
   </ItemGroup>
 </Project>

LazyProxy.Unity/LazyProxyUnityExtension.cs

@@ -0,0 +1,66 @@
+using System;
+using Unity.Builder;
+using Unity.Extension;
+using Unity.Injection;
+using Unity.Lifetime;
+using Unity.Policy;
+
+namespace LazyProxy.Unity
+{
+    /// <summary>
+    /// Allows to add a lazy registration to the container.
+    /// </summary>
+    public class LazyProxyUnityExtension : UnityContainerExtension
+    {
+        private readonly Type _typeFrom;
+        private readonly Type _typeTo;
+        private readonly string _name;
+        private readonly Func<ITypeLifetimeManager> _getLifetimeManager;
+        private readonly InjectionMember[] _injectionMembers;
+
+        /// <summary>
+        /// Initialize a new instance of <see cref="LazyProxyUnityExtension"/>.
+        /// </summary>
+        /// <param name="typeFrom">The binded interface.</param>
+        /// <param name="typeTo">The binded class.</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>
+        public LazyProxyUnityExtension(
+            Type typeFrom,
+            Type typeTo,
+            string name,
+            Func<ITypeLifetimeManager> getLifetimeManager,
+            params InjectionMember[] injectionMembers)
+        {
+            _typeFrom = typeFrom ?? throw new ArgumentNullException(nameof(typeFrom));
+            _typeTo = typeTo ?? throw new ArgumentNullException(nameof(typeTo));
+            _name = name;
+            _getLifetimeManager = getLifetimeManager ?? throw new ArgumentNullException(nameof(getLifetimeManager));
+            _injectionMembers = injectionMembers;
+        }
+
+        /// <inheritdoc />
+        protected override void Initialize()
+        {
+            var registrationName = Guid.NewGuid().ToString();
+
+            Context.Container.RegisterType(_typeFrom, _typeTo, _name, _getLifetimeManager());
+            Context.Container.RegisterType(_typeFrom, _typeTo, registrationName, _getLifetimeManager(), _injectionMembers);
+
+            Context.Policies.Set(_typeFrom, _name, typeof(ResolveDelegateFactory),
+                (ResolveDelegateFactory) ((ref BuilderContext _) =>
+                    (ref BuilderContext c) =>
+                    {
+                        var container = c.Container;
+                        var type = c.RegistrationType;
+                        var overrides = c.Overrides;
+
+                        return LazyProxyBuilder.CreateInstance(type,
+                            () => container.Resolve(type, registrationName, overrides)
+                        );
+                    })
+            );
+        }
+    }
+}

LazyProxy.Unity/UnityExtensions.cs

@@ -1,7 +1,7 @@
 using System;
 using Unity;
+using Unity.Injection;
 using Unity.Lifetime;
-using Unity.Registration;
 
 namespace LazyProxy.Unity
 {
@@ -10,7 +10,8 @@ namespace LazyProxy.Unity
     /// </summary>
     public static class UnityExtensions
     {
-        private static readonly Func<LifetimeManager> GetTransientLifetimeManager = () => new TransientLifetimeManager();
+        private static readonly Func<ITypeLifetimeManager> GetTransientLifetimeManager =
+            () => new TransientLifetimeManager();
 
         /// <summary>
         /// Is used to register interface TFrom to class TTo by creation a lazy proxy at runtime.
@@ -53,7 +54,7 @@ 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,
+            Func<ITypeLifetimeManager> getLifetimeManager,
             params InjectionMember[] injectionMembers)
             where TTo : TFrom where TFrom : class =>
             container.RegisterLazy<TFrom, TTo>(null, getLifetimeManager, injectionMembers);
@@ -71,7 +72,7 @@ public static IUnityContainer RegisterLazy<TFrom, TTo>(this IUnityContainer cont
         /// <returns>The instance of Unity container.</returns>
         public static IUnityContainer RegisterLazy<TFrom, TTo>(this IUnityContainer container,
             string name,
-            Func<LifetimeManager> getLifetimeManager,
+            Func<ITypeLifetimeManager> getLifetimeManager,
             params InjectionMember[] injectionMembers)
             where TTo : TFrom where TFrom : class =>
             container.RegisterLazy(typeof(TFrom), typeof(TTo), name, getLifetimeManager, injectionMembers);
@@ -121,7 +122,7 @@ public static IUnityContainer RegisterLazy(this IUnityContainer container,
         public static IUnityContainer RegisterLazy(this IUnityContainer container,
             Type typeFrom,
             Type typeTo,
-            Func<LifetimeManager> getLifetimeManager,
+            Func<ITypeLifetimeManager> getLifetimeManager,
             params InjectionMember[] injectionMembers) =>
             container.RegisterLazy(typeFrom, typeTo, null, getLifetimeManager, injectionMembers);
 
@@ -140,7 +141,7 @@ public static IUnityContainer RegisterLazy(this IUnityContainer container,
             Type typeFrom,
             Type typeTo,
             string name,
-            Func<LifetimeManager> getLifetimeManager,
+            Func<ITypeLifetimeManager> getLifetimeManager,
             params InjectionMember[] injectionMembers)
         {
             // There is no way to constraint it on the compilation step.
@@ -149,12 +150,42 @@ public static IUnityContainer RegisterLazy(this IUnityContainer container,
                 throw new NotSupportedException("The lazy registration is supported only for interfaces.");
             }
 
-            var registrationName = Guid.NewGuid().ToString();
+//          Note #1
+//          -------
+//          If UnityContainer has the correct overload of the '.RegisterFactory' method we can make it easier:
+//
+//          var registrationName = Guid.NewGuid().ToString();
+//          return container
+//              .RegisterType(typeFrom, typeTo, registrationName, getLifetimeManager(), injectionMembers)
+//              .RegisterFactory(typeFrom, name,
+//                  (c, t, n, o) => LazyProxyBuilder.CreateInstance(t, () => c.Resolve(t, registrationName, o)),
+//                  getLifetimeManager());
+//
+//          We opened an issue on GitHub and suggested pull requests to introduce the overload:
+//              - https://github.com/unitycontainer/container/issues/147
+//              - https://github.com/unitycontainer/abstractions/pull/98
+//              - https://github.com/unitycontainer/container/pull/148
+//
+//          But unfortunately the issue and pull requests were rejected for reasons not entirely clear.
+//          That is why we have to use extension.
+//
+//          Note #2
+//          -------
+//          We have to use an extension per type because UnityContainer has weird behaviour when work with
+//          open generic types therefore we can't use fake interface to avoid multiple extensions:
+//
+//          public interface ILazyProxy<T> {}
+//
+//          ...then register types like this:
+//          container.Register(_typeFrom, _typeTo,  "LazyProxyImpl" + _name);
+//          container.Register(_typeFrom, typeof(ILazyProxy<>).MakeGenericType(_typeFrom), _name);
+//
+//          ...and use single extension per container:
+//          context.Policy.Set(typeof(ILazyProxy<>), ...)
 
-            return container
-                .RegisterType(typeFrom, typeTo, registrationName, getLifetimeManager(), injectionMembers)
-                .RegisterType(typeFrom, name, getLifetimeManager(), new UnityInjectionFactory(
-                    (c, t, n, o) => LazyProxyBuilder.CreateInstance(t, () => c.Resolve(t, registrationName, o))));
+            return container.AddExtension(
+                new LazyProxyUnityExtension(typeFrom, typeTo, name, getLifetimeManager, injectionMembers)
+            );
         }
     }
 }