Revert "Update Autofac to 6.0.0"

hypercodeplace · hypercodeplace · commit a29f3281e326 · 2020-10-01T23:33:49.000-07:00
This reverts commit 4eace2a.
diff --git a/LazyProxy.Autofac.Tests/AutofacExtensionTests.cs b/LazyProxy.Autofac.Tests/AutofacExtensionTests.cs
@@ -19,34 +19,8 @@ public class AutofacExtensionTests
         [Theory]
         [InlineData(null)]
         [InlineData("name")]
-        public void RegisterLazyMustThrowNotSupportedExceptionForNonInterfaces(string name) =>
-            Assert.Throws<NotSupportedException>(() =>
-                new ContainerBuilder().RegisterLazy<Service1, Service1>(name));
-
-        [Theory]
-        [InlineData(null)]
-        [InlineData("name")]
-        public void RegisterGenericLazyMustThrowNotSupportedExceptionForNonInterfaces(string name) =>
-            Assert.Throws<NotSupportedException>(() =>
-                new ContainerBuilder().RegisterGenericLazy(
-                    typeof(GenericService<,,>),
-                    typeof(GenericService<,,>), name));
-
-        [Theory]
-        [InlineData(null)]
-        [InlineData("name")]
-        public void RegisterLazyMustThrowArgumentExceptionForOpenGenericInterface(string name) =>
-            Assert.Throws<ArgumentException>(() =>
-                new ContainerBuilder().RegisterLazy(
-                    typeof(IGenericService<,,>),
-                    typeof(GenericService<,,>), name));
-
-        [Theory]
-        [InlineData(null)]
-        [InlineData("name")]
-        public void RegisterGenericLazyMustThrowArgumentExceptionForNonOpenGenericInterface(string name) =>
-            Assert.Throws<ArgumentException>(() =>
-                new ContainerBuilder().RegisterGenericLazy(typeof(IService1), typeof(Service1), name));
+        public void RegistrationMustThrowNotSupportedExceptionForNonInterfaces(string name) =>
+            Assert.Throws<NotSupportedException>(() => new ContainerBuilder().RegisterLazy<Service1, Service1>(name));
 
         [Theory]
         [InlineData(null)]
@@ -361,7 +335,7 @@ public void ClosedGenericServiceMustBeResolved(string name)
         public void OpenGenericServiceMustBeResolved(string name)
         {
             var containerBuilder = new ContainerBuilder();
-            containerBuilder.RegisterGenericLazy(typeof(IGenericService<,,>), typeof(GenericService<,,>), name);
+            containerBuilder.RegisterLazy(typeof(IGenericService<,,>), typeof(GenericService<,,>), name);
 
             using (var container = containerBuilder.Build())
             {
@@ -409,6 +383,30 @@ public void NonLazyRegistrationMutatorMustBeApplied(string name)
             }
         }
 
+        [Theory]
+        [InlineData(null)]
+        [InlineData("name")]
+        public void RegisterLazyMustNotAddOpenGenericFactoryRegistrationSourceForNonOpenGenericTypes(
+            string name)
+        {
+            var containerBuilder = new ContainerBuilder();
+
+            containerBuilder.RegisterLazy(typeof(IService1), typeof(Service1), name);
+
+            containerBuilder.RegisterLazy(
+                typeof(IGenericService<ParameterType1, ParameterType2, ParameterType3>),
+                typeof(GenericService<ParameterType1, ParameterType2, ParameterType3>), name);
+
+            using (var container = containerBuilder.Build())
+            {
+                var count = container.ComponentRegistry.Sources
+                    .OfType<OpenGenericFactoryRegistrationSource>()
+                    .Count();
+
+                Assert.Equal(0, count);
+            }
+        }
+
         #region Lifetime tests
 
         [Theory]
@@ -461,6 +459,58 @@ public void InstancePerDependencyServiceLifetimeMustBeActualForOpenGenericServic
 
         #endregion
 
+        #region RegisterGenericFactory tests
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("name")]
+        public void RegisterGenericFactoryMustBeCorrect(string name)
+        {
+            void Test<T>() where T : IGenericService<ParameterType1, ParameterType2, ParameterType3>
+            {
+                var parameters = new Parameter[]
+                {
+                    new NamedParameter("key1", "value1"),
+                    new NamedParameter("key2", "value2")
+                };
+
+                var containerBuilder = new ContainerBuilder();
+                containerBuilder.RegisterGenericFactory(typeof(T).GetGenericTypeDefinition(), name,
+                    (c, t, n, p) =>
+                    {
+                        Assert.Same(typeof(T), t);
+                        Assert.Same(name, n);
+
+                        foreach (var parameter in parameters)
+                        {
+                            Assert.Contains(parameter, p);
+                        }
+
+                        return new GenericService<ParameterType1, ParameterType2, ParameterType3>();
+                    });
+
+                using (var container = containerBuilder.Build())
+                {
+                    var service = name == null
+                        ? container.Resolve<T>(parameters)
+                        : container.ResolveNamed<T>(name, parameters);
+
+                    var result = service.Get(new ParameterType1(), new ParameterType2(), 42);
+
+                    Assert.Equal(
+                        $"{typeof(ParameterType1).Name}_" +
+                        $"{typeof(ParameterType2).Name}_" +
+                        $"{typeof(int).Name}",
+                        result.Value);
+                }
+            }
+
+            Test<IGenericService<ParameterType1, ParameterType2, ParameterType3>>();
+            Test<GenericService<ParameterType1, ParameterType2, ParameterType3>>();
+        }
+
+        #endregion
+
         #region Private members
 
         [ThreadStatic] private static string _service1Id;
@@ -511,14 +561,7 @@ private IEnumerable<Guid> All()
         private static void AssertSingleInstanceServiceLifetimeMustBeActual<T>(Type typeFrom, Type typeTo, string name)
         {
             var containerBuilder = new ContainerBuilder();
-            if (typeFrom.IsGenericTypeDefinition)
-            {
-                containerBuilder.RegisterGenericLazy(typeFrom, typeTo, name).SingleInstance();
-            }
-            else
-            {
-                containerBuilder.RegisterLazy(typeFrom, typeTo, name).SingleInstance();
-            }
+            containerBuilder.RegisterLazy(typeFrom, typeTo, name).SingleInstance();
 
             using (var container = containerBuilder.Build())
             {
@@ -542,14 +585,7 @@ private static void AssertInstancePerLifetimeScopeServiceLifetimeMustBeActual<T>
             Type typeFrom, Type typeTo, string name)
         {
             var containerBuilder = new ContainerBuilder();
-            if (typeFrom.IsGenericTypeDefinition)
-            {
-                containerBuilder.RegisterGenericLazy(typeFrom, typeTo, name).InstancePerLifetimeScope();
-            }
-            else
-            {
-                containerBuilder.RegisterLazy(typeFrom, typeTo, name).InstancePerLifetimeScope();
-            }
+            containerBuilder.RegisterLazy(typeFrom, typeTo, name).InstancePerLifetimeScope();
 
             using (var container = containerBuilder.Build())
             {
@@ -582,14 +618,7 @@ private static void AssertInstancePerDependencyServiceLifetimeMustBeActual<T>(
             Type typeFrom, Type typeTo, string name)
         {
             var containerBuilder = new ContainerBuilder();
-            if (typeFrom.IsGenericTypeDefinition)
-            {
-                containerBuilder.RegisterGenericLazy(typeFrom, typeTo, name).InstancePerDependency();
-            }
-            else
-            {
-                containerBuilder.RegisterLazy(typeFrom, typeTo, name).InstancePerDependency();
-            }
+            containerBuilder.RegisterLazy(typeFrom, typeTo, name).InstancePerDependency();
 
             using (var container = containerBuilder.Build())
             {
@@ -837,6 +866,13 @@ public GenericService()
             }
         }
 
+        // ReSharper disable once MemberCanBePrivate.Global
+        public interface IGenericService2<T>
+        {
+            // ReSharper disable once UnusedMember.Global
+            T Get(T arg1);
+        }
+
         #endregion
     }
 }
diff --git a/LazyProxy.Autofac.Tests/LazyProxy.Autofac.Tests.csproj b/LazyProxy.Autofac.Tests/LazyProxy.Autofac.Tests.csproj
@@ -6,7 +6,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Autofac.Extras.DynamicProxy" Version="6.0.0" />
+        <PackageReference Include="Autofac.Extras.DynamicProxy" Version="5.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.6.0" />
         <PackageReference Include="Moq" Version="4.9.0" />
         <PackageReference Include="xunit" Version="2.3.1" />
diff --git a/LazyProxy.Autofac/AutofacExtensions.cs b/LazyProxy.Autofac/AutofacExtensions.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using Autofac;
 using Autofac.Builder;
 using Autofac.Core;
-using Autofac.Features.OpenGenerics;
+using Autofac.Core.Activators.Delegate;
 
 namespace LazyProxy.Autofac
 {
@@ -12,8 +14,27 @@ namespace LazyProxy.Autofac
     /// </summary>
     public static class AutofacExtensions
     {
+        private static readonly ConstructorInfo RegistrationBuilderConstructor;
+
+        static AutofacExtensions()
+        {
+            // There is no way to create RegistrationBuilder with TypedService / KeyedService without reflection.
+            RegistrationBuilderConstructor = typeof(ILifetimeScope).Assembly
+                .GetType("Autofac.Builder.RegistrationBuilder`3")
+                .MakeGenericType(
+                    typeof(object),
+                    typeof(SimpleActivatorData),
+                    typeof(SingleRegistrationStyle))
+                .GetConstructor(new[]
+                {
+                    typeof(Service),
+                    typeof(SimpleActivatorData),
+                    typeof(SingleRegistrationStyle)
+                });
+        }
+
         /// <summary>
-        /// Is used to register non open generic interface TFrom to class TTo by creation a lazy proxy at runtime.
+        /// 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="builder">The instance of the Autofac container builder.</param>
@@ -29,7 +50,7 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
             builder.RegisterLazy(typeof(TFrom), typeof(TTo), name, nonLazyRegistrationMutator);
 
         /// <summary>
-        /// Is used to register non open generic interface TFrom to class TTo by creation a lazy proxy at runtime.
+        /// 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 linked interface.</param>
@@ -45,68 +66,73 @@ public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrati
             // There is no way to constraint it on the compilation step.
             if (!typeFrom.IsInterface)
             {
-                throw new NotSupportedException(
-                    "The lazy registration is supported only for interfaces.");
+                throw new NotSupportedException("The lazy registration is supported only for interfaces.");
             }
 
+            var registrationName = Guid.NewGuid().ToString();
+            IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle> registration;
+
             if (typeTo.IsGenericTypeDefinition)
             {
-                throw new ArgumentException(
-                    $"{typeFrom} is an open generic type definition. Use the 'RegisterGenericLazy' method instead.");
-            }
+                var nonLazyRegistration = builder.RegisterGeneric(typeTo).Named(registrationName, typeFrom);
+                nonLazyRegistrationMutator?.Mutate(nonLazyRegistration);
 
-            var registrationName = Guid.NewGuid().ToString();
-            var nonLazyRegistration = builder.RegisterType(typeTo).Named(registrationName, typeFrom);
-            nonLazyRegistrationMutator?.Mutate(nonLazyRegistration);
+                registration = builder.RegisterGenericFactory(typeFrom, name,
+                    (c, t, n, p) => CreateLazyProxy(c, t, registrationName, p));
+            }
+            else
+            {
+                var nonLazyRegistration = builder.RegisterType(typeTo).Named(registrationName, typeFrom);
+                nonLazyRegistrationMutator?.Mutate(nonLazyRegistration);
 
-            var registration = builder.Register((c, p) =>
-                CreateLazyProxy(c.Resolve<IComponentContext>(), typeFrom, registrationName, p));
+                registration = builder.Register(
+                    (c, p) => CreateLazyProxy(c.Resolve<IComponentContext>(), typeFrom, registrationName, p));
+            }
 
             return name == null
                 ? registration.As(typeFrom)
                 : registration.Named(name, typeFrom);
         }
 
         /// <summary>
-        /// Is used to register open generic 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.
+        /// Registers a delegate as a component for open generic types.
         /// </summary>
-        /// <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>
-        /// <param name="nonLazyRegistrationMutator">A mutator allowing to change the non-lazy registration.</param>
-        /// <returns>The instance of the Autofac registration builder.</returns>
-        public static IRegistrationBuilder<object, OpenGenericDelegateActivatorData, DynamicRegistrationStyle>
-            RegisterGenericLazy(this ContainerBuilder builder, Type typeFrom, Type typeTo, string name = null,
-                IRegistrationMutator nonLazyRegistrationMutator = null)
+        /// <param name="type"><see cref="Type"/> of the registered component.</param>
+        /// <param name="name">Name of the registered component.</param>
+        /// <param name="factory">The delegate to register.</param>
+        /// <returns>Registration builder allowing the registration to be configured.</returns>
+        public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle>
+            RegisterGenericFactory(this ContainerBuilder builder, Type type, string name,
+                Func<IComponentContext, Type, string, Parameter[], object> factory)
         {
-            // There is no way to constraint it on the compilation step.
-            if (!typeFrom.IsInterface)
-            {
-                throw new NotSupportedException(
-                    "The lazy registration is supported only for interfaces.");
-            }
+            var registration = (IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle>)
+                RegistrationBuilderConstructor.Invoke(new[]
+                {
+                    string.IsNullOrEmpty(name)
+                        ? (object) new TypedService(type)
+                        : new KeyedService(name, type),
 
-            if (!typeTo.IsGenericTypeDefinition)
-            {
-                throw new ArgumentException(
-                    $"{typeFrom} is not an open generic type definition. Use the 'RegisterLazy' method instead.");
-            }
+                    new SimpleActivatorData(new DelegateActivator(type,
+                        (c, p) =>
+                        {
+                            var parameters = p.ToArray();
+                            var serviceType = parameters.Named<Type>(OpenGenericFactoryRegistrationSource.ServiceType);
+                            var context = c.Resolve<IComponentContext>();
 
-            var registrationName = Guid.NewGuid().ToString();
-            var nonLazyRegistration = builder.RegisterGeneric(typeTo).Named(registrationName, typeFrom);
-            nonLazyRegistrationMutator?.Mutate(nonLazyRegistration);
+                            return factory(context, serviceType, name, parameters);
+                        })),
 
-            var registration = builder.RegisterGeneric((c, t, p) =>
-            {
-                var closedTypeFrom = typeFrom.MakeGenericType(t);
-                return CreateLazyProxy(c.Resolve<IComponentContext>(), closedTypeFrom, registrationName, p);
-            });
+                    new SingleRegistrationStyle()
+                });
 
-            return name == null
-                ? registration.As(typeFrom)
-                : registration.Named(name, typeFrom);
+            registration.RegistrationData.DeferredCallback = builder.RegisterCallback(
+                cr => cr.AddRegistrationSource(
+                    new OpenGenericFactoryRegistrationSource(
+                        registration.RegistrationData,
+                        registration.ActivatorData)));
+
+            return registration;
         }
 
         private static object CreateLazyProxy(
diff --git a/LazyProxy.Autofac/LazyProxy.Autofac.csproj b/LazyProxy.Autofac/LazyProxy.Autofac.csproj
@@ -17,7 +17,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Autofac" Version="6.0.0" />
+        <PackageReference Include="Autofac" Version="5.2.0" />
         <PackageReference Include="LazyProxy" Version="1.0.0" />
     </ItemGroup>
 
diff --git a/LazyProxy.Autofac/OpenGenericFactoryRegistrationSource.cs b/LazyProxy.Autofac/OpenGenericFactoryRegistrationSource.cs
