Enable Property Injection only for types in an assembly containing an AbpModule

src/Volo.Abp.Autofac/Autofac/Builder/AbpRegistrationBuilderExtensions.cs

@@ -1,39 +1,75 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using Autofac.Core;
 using Autofac.Extras.DynamicProxy;
-using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.Castle.DynamicProxy;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Modularity;
 
 namespace Autofac.Builder
 {
     public static class AbpRegistrationBuilderExtensions
     {
         public static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> ConfigureAbpConventions<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
-            this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder,
+                this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder, 
-            IServiceCollection services)
+                IModuleContainer moduleContainer, 
+                ServiceRegistrationActionList registrationActionList)
             where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData
         {
-            registrationBuilder = registrationBuilder.PropertiesAutowired();
-
             var serviceType = registrationBuilder.RegistrationData.Services.OfType<IServiceWithType>().FirstOrDefault()?.ServiceType;
             if (serviceType == null)
             {
                 return registrationBuilder;
             }
 
+            var implementationType = registrationBuilder.ActivatorData.ImplementationType;
+            if (implementationType == null)
+            {
+                return registrationBuilder;
+            }
+
+            registrationBuilder = registrationBuilder.EnablePropertyInjection(moduleContainer, implementationType);
+            registrationBuilder = registrationBuilder.InvokeRegistrationActions(registrationActionList, serviceType);
+
+            return registrationBuilder;
+        }
+
+        private static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> InvokeRegistrationActions<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
+                this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder, 
+                ServiceRegistrationActionList registrationActionList,
+                Type serviceType) 
+            where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData
+        {
             var serviceRegistredArgs = new OnServiceRegistredContext(serviceType);
 
-            foreach (var registrationAction in services.GetRegistrationActionList())
+            foreach (var registrationAction in registrationActionList)
             {
                 registrationAction.Invoke(serviceRegistredArgs);
             }
 
             if (serviceRegistredArgs.Interceptors.Any())
             {
-                registrationBuilder = registrationBuilder.AddInterceptors(serviceRegistredArgs.Interceptors.ToArray());
+                registrationBuilder = registrationBuilder.AddInterceptors(
+                    serviceType,
+                    serviceRegistredArgs.Interceptors
+                );
+            }
+
+            return registrationBuilder;
+        }
+
+        private static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> EnablePropertyInjection<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
+                this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder, 
+                IModuleContainer moduleContainer,
+                Type implementationType) 
+            where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData
+        {
+            //Enable Property Injection only for types in an assembly containing an AbpModule
+            if (moduleContainer.Modules.Any(m => m.Assembly == implementationType.Assembly))
+            {
+                registrationBuilder = registrationBuilder.PropertiesAutowired();
             }
 
             return registrationBuilder;
@@ -41,11 +77,10 @@ namespace Autofac.Builder
 
         private static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> AddInterceptors<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
             this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder, 
-            Type[] interceptors)
+            Type serviceType,
+            IEnumerable<Type> interceptors)
             where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData
         {
-            var serviceType = registrationBuilder.RegistrationData.Services.OfType<IServiceWithType>().FirstOrDefault()?.ServiceType;
-
             registrationBuilder = serviceType.GetTypeInfo().IsInterface
                 ? registrationBuilder.EnableInterfaceInterceptors()
                 : registrationBuilder.EnableClassInterceptors();

src/Volo.Abp.Autofac/Autofac/Extensions/DependencyInjection/AutofacRegistration.cs

@@ -27,6 +27,7 @@ using System;
 using System.Reflection;
 using Autofac.Builder;
 using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.Modularity;
 
 namespace Autofac.Extensions.DependencyInjection
 {
@@ -100,6 +101,9 @@ namespace Autofac.Extensions.DependencyInjection
                 ContainerBuilder builder,
                 IServiceCollection services)
         {
+            var moduleContainer = services.GetSingletonInstance<IModuleContainer>();
+            var registrationActionList = services.GetRegistrationActionList();
+
             foreach (var service in services)
             {
                 if (service.ImplementationType != null)
@@ -119,7 +123,7 @@ namespace Autofac.Extensions.DependencyInjection
                             .RegisterType(service.ImplementationType)
                             .As(service.ServiceType)
                             .ConfigureLifecycle(service.Lifetime)
-                            .ConfigureAbpConventions(services);
+                            .ConfigureAbpConventions(moduleContainer, registrationActionList);
                     }
                 }
                 else if (service.ImplementationFactory != null)
@@ -131,6 +135,7 @@ namespace Autofac.Extensions.DependencyInjection
                     })
                     .ConfigureLifecycle(service.Lifetime)
                     .CreateRegistration();
+                    //TODO: ConfigureAbpConventions ?
 
                     builder.RegisterComponent(registration);
                 }

src/Volo.Abp/System/AbpTypeExtensions.cs

@@ -4,6 +4,7 @@ namespace System
 {
     public static class AbpTypeExtensions
     {
+        //TODO: This method can be removed because not needed anymore!
         public static Assembly GetAssembly(this Type type)
         {
             return type.GetTypeInfo().Assembly;

src/Volo.Abp/Volo/Abp/AbpApplicationBase.cs

@@ -32,8 +32,8 @@ namespace Volo.Abp
             var options = new AbpApplicationCreationOptions(services);
             optionsAction?.Invoke(options);
 
-            services.AddSingleton<IAbpApplication>(_ => this);
+            services.AddSingleton<IAbpApplication>(this);
-            services.AddSingleton<IModuleContainer>(_ => this);
+            services.AddSingleton<IModuleContainer>(this);
             services.AddCoreAbpServices();
 
             Modules = LoadModules(services, options);

src/Volo.Abp/Volo/Abp/AbpApplicationWithExternalServiceProvider.cs

@@ -16,7 +16,7 @@ namespace Volo.Abp
                 services, 
                 optionsAction)
         {
-            services.AddSingleton<IAbpApplicationWithExternalServiceProvider>(_ => this);
+            services.AddSingleton<IAbpApplicationWithExternalServiceProvider>(this);
         }
 
         public void Initialize(IServiceProvider serviceProvider)

src/Volo.Abp/Volo/Abp/AbpApplicationWithInternalServiceProvider.cs

@@ -29,7 +29,7 @@ namespace Volo.Abp
                 services, 
                 optionsAction)
         {
-            Services.AddSingleton<IAbpApplicationWithInternalServiceProvider>(_ => this);
+            Services.AddSingleton<IAbpApplicationWithInternalServiceProvider>(this);
         }
 
         public void Initialize()

src/Volo.Abp/Volo/Abp/Modularity/AbpModuleDescriptor.cs

@@ -10,6 +10,8 @@ namespace Volo.Abp.Modularity
     {
         public Type Type { get; }
 
+        public Assembly Assembly { get; }
+
         public IAbpModule Instance { get; }
 
         public bool IsLoadedAsPlugIn { get; }
@@ -31,6 +33,7 @@ namespace Volo.Abp.Modularity
             }
 
             Type = type;
+            Assembly = type.GetAssembly();
             Instance = instance;
             IsLoadedAsPlugIn = isLoadedAsPlugIn;
 

src/Volo.Abp/Volo/Abp/Modularity/IAbpModuleDescriptor.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Reflection;
 
 namespace Volo.Abp.Modularity
 {
@@ -7,6 +8,8 @@ namespace Volo.Abp.Modularity
     {
         Type Type { get; }
 
+        Assembly Assembly { get; }
+
         IAbpModule Instance { get; }
 
         bool IsLoadedAsPlugIn { get; }

test/Volo.Abp.AspNetCore.Mvc.Tests/Volo.Abp.AspNetCore.Mvc.Tests.csproj

@@ -17,6 +17,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\Volo.Abp.AspNetCore.Mvc\Volo.Abp.AspNetCore.Mvc.csproj" />
+    <ProjectReference Include="..\..\src\Volo.Abp.Autofac\Volo.Abp.Autofac.csproj" />
     <ProjectReference Include="..\Volo.Abp.AspNetCore.Tests\Volo.Abp.AspNetCore.Tests.csproj" />
   </ItemGroup>
 

test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/App/Startup.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Builder;
+using System;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -7,9 +8,16 @@ namespace Volo.Abp.AspNetCore.App
 {
     public class Startup
     {
-        public void ConfigureServices(IServiceCollection services)
+        public IServiceProvider ConfigureServices(IServiceCollection services)
         {
-            services.AddApplication<AppModule>();
+            services.AddApplication<AppModule>(options =>
+            {
+                options.UseAutofac();
+            });
+
+            //TODO: This is needed because ASP.NET Core does not use IServiceProviderFactory!
+            return services.BuildServiceProviderFromFactory();
+            //return services.BuildServiceProvider();
         }
 
         public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)