Add supporting of open generic types.

Author: hypercodeplace

LazyProxy.Autofac.Tests/AutofacExtensionTests.cs

@@ -404,11 +404,9 @@ public void InstancePerDependencyServiceLifetimeMustBeActualForOpenGenericServic
 
         #region Private members
 
-        [ThreadStatic]
-        private static string _service1Id;
+        [ThreadStatic] private static string _service1Id;
 
-        [ThreadStatic]
-        private static string _service2Id;
+        [ThreadStatic] private static string _service2Id;
 
         private const string Service1PropertyValue = nameof(Service1PropertyValue);
         private const string Service1MethodValue = nameof(Service1MethodValue);
@@ -456,7 +454,8 @@ private static void AssertSingleInstanceServiceLifetimeMustBeActual<T>(Type type
             var containerBuilder = new ContainerBuilder();
             containerBuilder.RegisterLazy(typeFrom, typeTo, name).SingleInstance();
 
-            using (var container = containerBuilder.Build()) {
+            using (var container = containerBuilder.Build())
+            {
                 var resolves = GetResolves<T>(container, name);
                 var rootContainerResolves = resolves.RootContainerResolves;
                 var childContainer1Resolves = resolves.Scope1Resolves;
@@ -479,7 +478,8 @@ private static void AssertInstancePerLifetimeScopeServiceLifetimeMustBeActual<T>
             var containerBuilder = new ContainerBuilder();
             containerBuilder.RegisterLazy(typeFrom, typeTo, name).InstancePerLifetimeScope();
 
-            using (var container = containerBuilder.Build()) {
+            using (var container = containerBuilder.Build())
+            {
                 var resolves = GetResolves<T>(container, name);
                 var rootContainerResolves = resolves.RootContainerResolves;
                 var childContainer1Resolves = resolves.Scope1Resolves;
@@ -511,7 +511,8 @@ private static void AssertInstancePerDependencyServiceLifetimeMustBeActual<T>(
             var containerBuilder = new ContainerBuilder();
             containerBuilder.RegisterLazy(typeFrom, typeTo, name).InstancePerDependency();
 
-            using (var container = containerBuilder.Build()) {
+            using (var container = containerBuilder.Build())
+            {
                 var resolves = GetResolves<T>(container, name)
                     .Where(id => id != Guid.Empty)
                     .ToArray();
@@ -521,21 +522,24 @@ private static void AssertInstancePerDependencyServiceLifetimeMustBeActual<T>(
         }
 
         private static Resolves GetResolves<T>(ILifetimeScope container, string name) =>
-            new Resolves {
+            new Resolves
+            {
                 RootContainerResolves = GetContainerResolves<T>(container, name),
                 Scope1Resolves = GetScopeResolves<T>(container, name),
                 Scope2Resolves = GetScopeResolves<T>(container, name)
             };
 
         private static SingleContainerResolves GetContainerResolves<T>(IComponentContext container, string name) =>
-            new SingleContainerResolves {
+            new SingleContainerResolves
+            {
                 Resolve1 = GetResolvedId<T>(container, name),
                 Resolve2 = GetResolvedId<T>(container, name),
             };
 
         private static SingleContainerResolves GetScopeResolves<T>(ILifetimeScope container, string name)
         {
-            using (var scope = container.BeginLifetimeScope()) {
+            using (var scope = container.BeginLifetimeScope())
+            {
                 return GetContainerResolves<T>(scope, name);
             }
         }
@@ -561,7 +565,9 @@ public interface IHasId
         }
 
         // ReSharper disable once MemberCanBePrivate.Global
-        public interface IService : IHasId { }
+        public interface IService : IHasId
+        {
+        }
 
         // ReSharper disable once MemberCanBePrivate.Global
         public class Service : IService
@@ -671,21 +677,29 @@ public ServiceToTestOverrides(SomeEnum someEnum, IService2 service, Argument arg
             }
         }
 
-        public interface IParameterType { }
+        public interface IParameterType
+        {
+        }
 
         public abstract class ParameterTypeBase
         {
             public string Value { get; set; }
         }
 
         // ReSharper disable once MemberCanBePrivate.Global
-        public class ParameterType1 : IParameterType { }
+        public class ParameterType1 : IParameterType
+        {
+        }
 
         // ReSharper disable once MemberCanBePrivate.Global
-        public struct ParameterType2 { }
+        public struct ParameterType2
+        {
+        }
 
         // ReSharper disable once MemberCanBePrivate.Global
-        public class ParameterType3 : ParameterTypeBase, IParameterType { }
+        public class ParameterType3 : ParameterTypeBase, IParameterType
+        {
+        }
 
         // ReSharper disable once MemberCanBePrivate.Global
         // ReSharper disable once TypeParameterCanBeVariant

LazyProxy.Autofac/AutofacExtensions.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Autofac;
 using Autofac.Builder;
+using Autofac.Core;
 
 namespace LazyProxy.Autofac
 {
@@ -14,8 +17,8 @@ public static class AutofacExtensions
         /// The real class To will be instantiated only after first method or property execution.
         /// </summary>
         /// <param name="builder">The instance of the Autofac container builder.</param>
-        /// <typeparam name="TFrom">The binded interface.</typeparam>
-        /// <typeparam name="TTo">The binded class.</typeparam>
+        /// <typeparam name="TFrom">The linked interface.</typeparam>
+        /// <typeparam name="TTo">The linked class.</typeparam>
         /// <returns>The instance of the Autofac registration builder.</returns>
         public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle>
             RegisterLazy<TFrom, TTo>(this ContainerBuilder builder)
@@ -28,8 +31,8 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
         /// </summary>
         /// <param name="builder">The instance of the Autofac container builder.</param>
         /// <param name="name">The registration name. Null if named registration is not required.</param>
-        /// <typeparam name="TFrom">The binded interface.</typeparam>
-        /// <typeparam name="TTo">The binded class.</typeparam>
+        /// <typeparam name="TFrom">The linked interface.</typeparam>
+        /// <typeparam name="TTo">The linked class.</typeparam>
         /// <returns>The instance of the Autofac registration builder.</returns>
         public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle>
             RegisterLazy<TFrom, TTo>(this ContainerBuilder builder, string name)
@@ -40,8 +43,8 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
         /// 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.
         /// </summary>
-        /// <param name="typeFrom">The binded interface.</param>
-        /// <param name="typeTo">The binded class.</param>
+        /// <param name="typeFrom">The linked interface.</param>
+        /// <param name="typeTo">The linked class.</param>
         /// <param name="builder">The instance of the Autofac container builder.</param>
         /// <returns>The instance of the Autofac registration builder.</returns>
         public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle>
@@ -52,8 +55,8 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
         /// 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="typeFrom">The binded interface.</param>
-        /// <param name="typeTo">The binded class.</param>
+        /// <param name="typeFrom">The linked interface.</param>
+        /// <param name="typeTo">The linked class.</param>
         /// <param name="builder">The instance of the Autofac container builder.</param>
         /// <param name="name">The registration name. Null if named registration is not required.</param>
         /// <returns>The instance of the Autofac registration builder.</returns>
@@ -66,22 +69,38 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
                 throw new NotSupportedException("The lazy registration is supported only for interfaces.");
             }
 
+            builder.RegisterSource<OpenGenericFactoryRegistrationSource>();
+
             var registrationName = Guid.NewGuid().ToString();
 
-            builder.RegisterType(typeTo).Named(registrationName, typeFrom);
+            if (typeTo.IsGenericTypeDefinition)
+            {
+                builder.RegisterGeneric(typeTo).Named(registrationName, typeFrom);
+            }
+            else
+            {
+                builder.RegisterType(typeTo).Named(registrationName, typeFrom);
+            }
 
             var registration = builder.Register((c, p) =>
             {
+                var parameters = p.ToList();
                 var context = c.Resolve<IComponentContext>();
+                var serviceType = GetServiceType(typeFrom, parameters);
 
-                return LazyProxyBuilder.CreateInstance(typeFrom,
-                    () => context.ResolveNamed(registrationName, typeFrom, p)
+                return LazyProxyBuilder.CreateInstance(serviceType,
+                    () => context.ResolveNamed(registrationName, serviceType, parameters)
                 );
             });
 
             return name == null
                 ? registration.As(typeFrom)
                 : registration.Named(name, typeFrom);
         }
+
+        private static Type GetServiceType(Type type, IEnumerable<Parameter> parameters) =>
+            type.IsGenericType && !type.IsConstructedGenericType
+                ? parameters.Named<Type>(OpenGenericFactoryRegistrationSource.ServiceType)
+                : type;
     }
 }

LazyProxy.Autofac/OpenGenericFactoryRegistrationSource.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Autofac;
+using Autofac.Core;
+using Autofac.Core.Activators.Delegate;
+using Autofac.Core.Lifetime;
+using Autofac.Core.Registration;
+
+namespace LazyProxy.Autofac
+{
+    /// <summary>
+    /// Generates registrations for open generic factories.
+    /// </summary>
+    public sealed class OpenGenericFactoryRegistrationSource : IRegistrationSource
+    {
+        /// <summary>
+        /// Name of the key to get the closed generic type from the named parameters.
+        /// </summary>
+        public const string ServiceType = "ServiceType";
+
+        /// <inheritdoc />
+        public bool IsAdapterForIndividualComponents => false;
+
+        /// <inheritdoc />
+        public IEnumerable<IComponentRegistration> RegistrationsFor(
+            Service service, Func<Service, IEnumerable<IComponentRegistration>> registrationAccessor)
+        {
+            if (service == null)
+            {
+                throw new ArgumentNullException(nameof(service));
+            }
+
+            if (registrationAccessor == null)
+            {
+                throw new ArgumentNullException(nameof(registrationAccessor));
+            }
+
+            if (!(service is IServiceWithType swt) || !swt.ServiceType.GetTypeInfo().IsGenericType)
+            {
+                return Enumerable.Empty<IComponentRegistration>();
+            }
+
+            var definitionService = (IServiceWithType) swt.ChangeType(swt.ServiceType.GetGenericTypeDefinition());
+            var factoryRegistrations = registrationAccessor((Service) definitionService);
+
+            return factoryRegistrations
+                .Where(factoryRegistration => factoryRegistration.Activator is DelegateActivator)
+                .Select(factoryRegistration =>
+                {
+                    return new ComponentRegistration(
+                        Guid.NewGuid(),
+                        new DelegateActivator(swt.ServiceType, (c, parameters) =>
+                        {
+                            var activator = (DelegateActivator) factoryRegistration.Activator;
+                            var newParameters = parameters.Concat(new[]
+                            {
+                                new NamedParameter(ServiceType, swt.ServiceType)
+                            });
+                            return activator.ActivateInstance(c, newParameters);
+                        }),
+                        GetLifetime(factoryRegistration.Lifetime),
+                        factoryRegistration.Sharing,
+                        factoryRegistration.Ownership,
+                        new[] {service},
+                        new Dictionary<string, object>());
+                });
+        }
+
+        private static IComponentLifetime GetLifetime(IComponentLifetime lifetime)
+        {
+            if (lifetime.GetType() == typeof(CurrentScopeLifetime))
+            {
+                return new CurrentScopeLifetime();
+            }
+
+            if (lifetime.GetType() == typeof(RootScopeLifetime))
+            {
+                return new RootScopeLifetime();
+            }
+
+            throw new NotSupportedException($"Lifetime scope '${lifetime.GetType().Name}' is not supported.");
+        }
+    }
+}