Fix : ResolveMany (#128)

Author: liuhaoyang

core/src/AspectCore.Core/Injector/ServiceCallSiteResolver.cs

@@ -11,19 +11,19 @@ namespace AspectCore.Injector
     internal class ServiceCallSiteResolver
     {
         private readonly ConstructorCallSiteResolver _constructorCallSiteResolver;
-        private readonly ConcurrentDictionary<ServiceDefinition, Func<IServiceResolver, object>> _resolvedCallSites;
+        private readonly ConcurrentDictionary<ServiceDefinition, Func<ServiceResolver, object>> _resolvedCallSites;
         public ServiceCallSiteResolver(ServiceTable serviceTable)
         {
             _constructorCallSiteResolver = new ConstructorCallSiteResolver(serviceTable);
-            _resolvedCallSites = new ConcurrentDictionary<ServiceDefinition, Func<IServiceResolver, object>>();
+            _resolvedCallSites = new ConcurrentDictionary<ServiceDefinition, Func<ServiceResolver, object>>();
         }
 
-        internal Func<IServiceResolver, object> Resolve(ServiceDefinition service)
+        internal Func<ServiceResolver, object> Resolve(ServiceDefinition service)
         {
             return _resolvedCallSites.GetOrAdd(service, ResolvePropertyInject);
         }
 
-        internal Func<IServiceResolver, object> ResolvePropertyInject(ServiceDefinition service)
+        internal Func<ServiceResolver, object> ResolvePropertyInject(ServiceDefinition service)
         {
             var callSite = ResolveInternal(service);
             if (!service.RequiredPropertyInjection())
@@ -44,7 +44,7 @@ internal Func<IServiceResolver, object> ResolvePropertyInject(ServiceDefinition
             };
         }
 
-        internal Func<IServiceResolver, object> ResolveInternal(ServiceDefinition service)
+        internal Func<ServiceResolver, object> ResolveInternal(ServiceDefinition service)
         {
             switch (service)
             {
@@ -65,40 +65,40 @@ internal Func<IServiceResolver, object> ResolveInternal(ServiceDefinition servic
             };
         }
 
-        private Func<IServiceResolver, object> ResolveManyEnumerableService(ManyEnumerableServiceDefintion manyEnumerableServiceDefintion)
+        private Func<ServiceResolver, object> ResolveManyEnumerableService(ManyEnumerableServiceDefintion manyEnumerableServiceDefintion)
         {
-            var elementResolvers = manyEnumerableServiceDefintion.ServiceDefinitions.Select(x => Resolve(x)).ToArray();
+            var elementDefinitions = manyEnumerableServiceDefintion.ServiceDefinitions.ToArray();
             var elementType = manyEnumerableServiceDefintion.ElementType;
             return resolver =>
             {
-                var length = elementResolvers.Length;
+                var length = elementDefinitions.Length;
                 var instance = Array.CreateInstance(elementType, length);
                 for (var i = 0; i < length; i++)
                 {
-                    instance.SetValue(elementResolvers[i](resolver), i);
+                    instance.SetValue(resolver.ResolveDefinition(elementDefinitions[i]), i);
                 }
                 return ActivatorUtils.CreateManyEnumerable(elementType, instance);
             };
         }
 
-        private Func<IServiceResolver, object> ResolveEnumerableService(EnumerableServiceDefintion enumerableServiceDefintion)
+        private Func<ServiceResolver, object> ResolveEnumerableService(EnumerableServiceDefintion enumerableServiceDefintion)
         {
-            var elementResolvers = enumerableServiceDefintion.ServiceDefinitions.Select(x => Resolve(x)).ToArray();
+            var elementDefinitions = enumerableServiceDefintion.ServiceDefinitions.ToArray();
             var elementType = enumerableServiceDefintion.ElementType;
             return resolver =>
             {
-                var length = elementResolvers.Length;
+                var length = elementDefinitions.Length;
                 var instance = Array.CreateInstance(elementType, length);
                 for (var i = 0; i < length; i++)
                 {
-                    var element = elementResolvers[i](resolver);
+                    var element = resolver.ResolveDefinition(elementDefinitions[i]);
                     instance.SetValue(element, i);
                 }
                 return instance;
             };
         }
 
-        private Func<IServiceResolver, object> ResolveProxyService(ProxyServiceDefinition proxyServiceDefinition)
+        private Func<ServiceResolver, object> ResolveProxyService(ProxyServiceDefinition proxyServiceDefinition)
         {
             if (proxyServiceDefinition.ServiceType.GetTypeInfo().IsClass)
             {
@@ -110,7 +110,7 @@ private Func<IServiceResolver, object> ResolveProxyService(ProxyServiceDefinitio
             return resolver => reflector.Invoke(resolver.ResolveRequired<IAspectActivatorFactory>(), serviceResolver(resolver));
         }
 
-        private Func<IServiceResolver, object> ResolveTypeService(TypeServiceDefinition typeServiceDefinition)
+        private Func<ServiceResolver, object> ResolveTypeService(TypeServiceDefinition typeServiceDefinition)
         {
             var callSite = _constructorCallSiteResolver.Resolve(typeServiceDefinition.ImplementationType);
             if (callSite == null)

core/src/AspectCore.Core/Injector/ServiceResolver.cs

@@ -46,6 +46,11 @@ public object Resolve(Type serviceType)
 
             var definition = _serviceTable.TryGetService(serviceType);
 
+            return ResolveDefinition(definition);
+        }
+
+        internal object ResolveDefinition(ServiceDefinition definition)
+        {
             if (definition == null)
             {
                 return null;

core/test/AspectCore.Tests/Injector/ManyEnumerableTest.cs

@@ -34,6 +34,40 @@ public void Resolve_Not_Register()
             Assert.NotNull(many);
             Assert.Equal(0, many.Count());
         }
+        
+        [Fact]
+        public void Resolve_Enumerable_Lifetime()
+        {
+            var many = ServiceResolver.Resolve<IEnumerable<IService>>().ToArray();
+            var many1 = ServiceResolver.Resolve<IEnumerable<IService>>().ToArray();
+            Assert.NotEqual(many[0], many1[0]);
+            Assert.Equal(many[1], many1[1]);
+            Assert.Equal(many[2], many1[2]);
+            using (var scope = ServiceResolver.CreateScope())
+            {
+                var many2 = scope.Resolve<IEnumerable<IService>>().ToArray();
+                Assert.NotEqual(many[0], many2[0]);
+                Assert.Equal(many[1], many2[1]);
+                Assert.NotEqual(many[2], many2[2]);
+            }
+        }
+        
+        [Fact]
+        public void Resolve_Many_Lifetime()
+        {
+            var many = ServiceResolver.ResolveMany<IService>().ToArray();
+            var many1 = ServiceResolver.ResolveMany<IService>().ToArray();
+            Assert.NotEqual(many[0], many1[0]);
+            Assert.Equal(many[1], many1[1]);
+            Assert.Equal(many[2], many1[2]);
+            using (var scope = ServiceResolver.CreateScope())
+            {
+                var many2 = scope.Resolve<IEnumerable<IService>>().ToArray();
+                Assert.NotEqual(many[0], many2[0]);
+                Assert.Equal(many[1], many2[1]);
+                Assert.NotEqual(many[2], many2[2]);
+            }
+        }
 
         protected override void ConfigureService(IServiceContainer serviceContainer)
         {