Improved module initialize and DI code.

src/Volo.Abp/Abp/AbpApplication.cs

@@ -8,7 +8,7 @@ namespace Volo.Abp
     {
         public Type StartupModuleType { get; }
 
-        private IServiceProvider _serviceProvider;
+        public IServiceProvider ServiceProvider { get; private set; }
 
         private AbpApplication(Type startupModuleType, IServiceCollection services)
         {
@@ -28,8 +28,8 @@ namespace Volo.Abp
 
         public void Initialize(IServiceProvider serviceProvider)
         {
-            _serviceProvider = serviceProvider;
+            ServiceProvider = serviceProvider;
-            _serviceProvider.GetRequiredService<IModuleManager>().Initialize();
+            ServiceProvider.GetRequiredService<IModuleManager>().Initialize();
         }
 
         public void Dispose()

src/Volo.Abp/Abp/AbpKernelModule.cs

@@ -1,17 +1,14 @@
-using System;
+using Microsoft.Extensions.DependencyInjection;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.Modularity;
+using Volo.DependencyInjection;
 
 namespace Volo.Abp
 {
-    public class AbpKernelModule : IAbpModule
+    public class AbpKernelModule : AbpModule
     {
-        public void ConfigureServices(IServiceCollection services)
+        public override void ConfigureServices(IServiceCollection services)
         {
-            
+            services.AddAssemblyOf<AbpKernelModule>();
         }
     }
 }

src/Volo.Abp/Abp/AbpServiceCollectionExtensions.cs

@@ -29,7 +29,6 @@ namespace Volo.Abp
         internal static void AddCoreAbpServices(this IServiceCollection services)
         {
             services.TryAddSingleton<IModuleLoader>(new ModuleLoader());
-            services.TryAddSingleton<IModuleManager, ModuleManager>();
         }
     }
 }

src/Volo.Abp/Abp/Modularity/AbpModule.cs

@@ -0,0 +1,17 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Volo.Abp.Modularity
+{
+    public abstract class AbpModule : IAbpModule, IOnApplicationInitialize
+    {
+        public virtual void ConfigureServices(IServiceCollection services)
+        {
+            
+        }
+
+        public virtual void OnApplicationInitialize()
+        {
+            
+        }
+    }
+}

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

@@ -19,6 +19,7 @@ namespace Volo.Abp.Modularity
 
             Type = type;
             Instance = instance;
+
             Dependencies = new List<AbpModuleDescriptor>();
         }
     }

src/Volo.Abp/Abp/Modularity/DefaultModuleInitializer.cs

@@ -0,0 +1,10 @@
+namespace Volo.Abp.Modularity
+{
+    public class DefaultModuleInitializer : IModuleInitializer
+    {
+        public void Initialize(IAbpModule module)
+        {
+            (module as IOnApplicationInitialize)?.OnApplicationInitialize();
+        }
+    }
+}

src/Volo.Abp/Abp/Modularity/DependsOnAttribute.cs

@@ -23,7 +23,7 @@ namespace Volo.Abp.Modularity
             DependedModuleTypes = dependedModuleTypes;
         }
 
-        public Type[] GetDependedModuleTypes()
+        public virtual Type[] GetDependedModuleTypes()
         {
             return DependedModuleTypes;
         }

src/Volo.Abp/Abp/Modularity/IModuleLoader.cs

@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.Extensions.DependencyInjection;
-using Volo.DependencyInjection;
 
 namespace Volo.Abp.Modularity
 {
-    public interface IModuleLoader : ISingletonDependency
+    public interface IModuleLoader
     {
         IReadOnlyList<AbpModuleDescriptor> Modules { get; }
 

src/Volo.Abp/Abp/Modularity/IOnApplicationInitialize.cs

@@ -0,0 +1,7 @@
+namespace Volo.Abp.Modularity
+{
+    public interface IOnApplicationInitialize
+    {
+        void OnApplicationInitialize();
+    }
+}

src/Volo.Abp/Abp/Modularity/ModuleLoader.cs

@@ -25,17 +25,17 @@ namespace Volo.Abp.Modularity
                 throw new InvalidOperationException($"{nameof(LoadAll)} should be called only once!");
             }
 
-            FillModules(startupModuleType);
+            FillModules(services, startupModuleType);
             SetModuleDependencies();
             SortByDependency(startupModuleType);
             ConfigureServices(services);
         }
 
-        private void FillModules(Type startupModuleType)
+        private void FillModules(IServiceCollection services, Type startupModuleType)
         {
             foreach (var moduleType in FindAllModuleTypes(startupModuleType).Distinct())
             {
-                _modules.Add(CreateModuleDescriptor(moduleType));
+                _modules.Add(CreateModuleDescriptor(services, moduleType));
             }
         }
 
@@ -62,9 +62,16 @@ namespace Volo.Abp.Modularity
             return moduleTypes;
         }
 
-        protected virtual AbpModuleDescriptor CreateModuleDescriptor(Type moduleType)
+        protected virtual AbpModuleDescriptor CreateModuleDescriptor(IServiceCollection services, Type moduleType)
         {
-            return new AbpModuleDescriptor(moduleType, (IAbpModule)Activator.CreateInstance(moduleType));
+            return new AbpModuleDescriptor(moduleType, CreateAndRegisterModule(services, moduleType));
+        }
+
+        private IAbpModule CreateAndRegisterModule(IServiceCollection services, Type moduleType)
+        {
+            var module = (IAbpModule) Activator.CreateInstance(moduleType);
+            services.AddSingleton(moduleType, module);
+            return module;
         }
 
         protected virtual void ConfigureServices(IServiceCollection services)

src/Volo.Abp/Abp/Modularity/ModuleManager.cs

@@ -1,8 +1,9 @@
 using System.Collections.Generic;
+using Volo.DependencyInjection;
 
 namespace Volo.Abp.Modularity
 {
-    public class ModuleManager : IModuleManager
+    public class ModuleManager : IModuleManager, ISingletonDependency
     {
         private readonly IModuleLoader _moduleLoader;
         private readonly IEnumerable<IModuleInitializer> _initializers;

src/Volo.DependencyInjection/DependencyInjection/AbpConventionalDependencyInjectionExtensions.cs

@@ -19,7 +19,13 @@ namespace Volo.DependencyInjection
 
         public static void AddAssembly(this IServiceCollection services, Assembly assembly)
         {
-            services.AddTypes(AssemblyHelper.GetAllTypes(assembly).FilterInjectableTypes().ToArray());
+            var types = AssemblyHelper.GetAllTypes(assembly).Where(t =>
+            {
+                var typeInfo = t.GetTypeInfo();
+                return typeInfo.IsClass && !typeInfo.IsAbstract && !typeInfo.IsGenericType && !typeInfo.IsDefined(typeof(DisableAutoDependencyInjectionRegistrationAttribute));
+            });
+            
+            services.AddTypes(types.ToArray());
         }
 
         public static void AddTypes(this IServiceCollection services, params Type[] types)
@@ -81,14 +87,5 @@ namespace Volo.DependencyInjection
 
             return serviceTypes;
         }
-
-        private static IEnumerable<Type> FilterInjectableTypes(this IEnumerable<Type> types)
-        {
-            return types.Where(t =>
-            {
-                var typeInfo = t.GetTypeInfo();
-                return typeInfo.IsClass && !typeInfo.IsAbstract && !typeInfo.IsGenericType;
-            });
-        }
     }
 }

src/Volo.DependencyInjection/DependencyInjection/DisableAutoDependencyInjectionRegistrationAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Volo.DependencyInjection
+{
+    public class DisableAutoDependencyInjectionRegistrationAttribute : Attribute
+    {
+
+    }
+}

test/Volo.Abp.Tests/AbpApplication_Tests.cs

@@ -1,4 +1,5 @@
 using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
 using Volo.Abp.Tests.Modularity;
 using Xunit;
 
@@ -7,13 +8,23 @@ namespace Volo.Abp.Tests
     public class AbpApplication_Tests
     {
         [Fact]
-        public void Should_Start_And_Stop_Empty_Application()
+        public void Should_Initialize_SingleModule_Application()
         {
+            //Arrange
+
             var services = new ServiceCollection();
 
             using (var application = AbpApplication.Create<IndependentEmptyModule>(services))
             {
+                //Act
+
                 application.Initialize(services.BuildServiceProvider());
+
+                //Assert
+
+                var module = application.ServiceProvider.GetRequiredService<IndependentEmptyModule>();
+                module.ConfigureServicesIsCalled.ShouldBeTrue();
+                module.OnApplicationInitializeIsCalled.ShouldBeTrue();
             }
         }
     }

test/Volo.Abp.Tests/Modularity/IndependentEmptyModule.cs

@@ -3,11 +3,20 @@ using Volo.Abp.Modularity;
 
 namespace Volo.Abp.Tests.Modularity
 {
-    public class IndependentEmptyModule : IAbpModule
+    public class IndependentEmptyModule : AbpModule
     {
-        public void ConfigureServices(IServiceCollection services)
+        public bool ConfigureServicesIsCalled { get; set; }
+
+        public bool OnApplicationInitializeIsCalled { get; set; }
+
+        public override void ConfigureServices(IServiceCollection services)
+        {
+            ConfigureServicesIsCalled = true;
+        }
+
+        public override void OnApplicationInitialize()
         {
-            
+            OnApplicationInitializeIsCalled = true;
         }
     }
 }