Merge branch 'dev' of github.com:afresh/abp into dev

abp_io/AbpIoLocalization/AbpIoLocalization/Commercial/Localization/Resources/en.json

@@ -193,7 +193,7 @@
     "WhatHappensWhenLicenseEnds": "What happens when my license period ends?",
     "WhatHappensWhenLicenseEndsExplanation1": "ABP Commercial license type is <a href=\"{0}\" target=\"_blank\">perpetual license</a>. After your license expires, you can continue developing your project. And you are not obliged to renew your license. Your license comes with a one-year Updates and Support plan out of the box. To continue to receive new features, performance enhancements, bug fixes, support and continue to use ABP Suite, make sure to renew your plan each year. When your license expires, you will not be able to get more of the following benefits;",
     "WhatHappensWhenLicenseEndsExplanation2": "You can not create new solutions using the ABP Commercial, but you can continue to develop your existing applications forever.",
-    "WhatHappensWhenLicenseEndsExplanation3": "You will be able to get updates for the modules and themes within your MAJOR version. For example; if you are using v3.2.0 of a module, you can still get updates for v3.x.x (v3.3.0, v3.5.2... etc.) of that module. But you cannot get updates for the next major version (like v4.x, v5.x)",
+    "WhatHappensWhenLicenseEndsExplanation3": "You will be able to get updates for the modules and themes within your MAJOR version (except RC or Preview versions). For example; if you are using v3.2.0 of a module, you can still get updates for v3.x.x (v3.3.0, v3.5.2... etc.) of that module. But you cannot get updates for the next major version (like v4.x, v5.x). Let's say, when your license expired, the latest release was v4.4.3 and the latest preview version was v5.0.0-rc.2, you can only access the v4.X.X but you cannot access the v5.X.X.",
     "WhatHappensWhenLicenseEndsExplanation4": "You can not install new modules and themes added to the ABP Commercial platform after your license ends.",
     "WhatHappensWhenLicenseEndsExplanation5": "You can not use the ABP Suite.",
     "WhatHappensWhenLicenseEndsExplanation6": "You can not get the <a href=\"{0}\">premium support</a> anymore.",

framework/src/Volo.Abp.AspNetCore.Components.WebAssembly/Microsoft/AspNetCore/Components/WebAssembly/Hosting/AbpWebAssemblyHostBuilderExtensions.cs

@@ -17,6 +17,30 @@ namespace Microsoft.AspNetCore.Components.WebAssembly.Hosting;
 
 public static class AbpWebAssemblyHostBuilderExtensions
 {
+    public static async Task<IAbpApplicationWithExternalServiceProvider> AddApplicationAsync<TStartupModule>(
+        [NotNull] this WebAssemblyHostBuilder builder,
+        Action<AbpWebAssemblyApplicationCreationOptions> options)
+        where TStartupModule : IAbpModule
+    {
+        Check.NotNull(builder, nameof(builder));
+
+        // Related this commit(https://github.com/dotnet/aspnetcore/commit/b99d805bc037fcac56afb79abeb7d5a43141c85e)
+        // Microsoft.AspNetCore.Blazor.BuildTools has been removed in net 5.0.
+        // This call may be removed when we find a suitable solution.
+        // System.Runtime.CompilerServices.AsyncStateMachineAttribute
+        Castle.DynamicProxy.Generators.AttributesToAvoidReplicating.Add<AsyncStateMachineAttribute>();
+
+        builder.Services.AddSingleton<IConfiguration>(builder.Configuration);
+        builder.Services.AddSingleton(builder);
+
+        var application = await builder.Services.AddApplicationAsync<TStartupModule>(opts =>
+        {
+            options?.Invoke(new AbpWebAssemblyApplicationCreationOptions(builder, opts));
+        });
+
+        return application;
+    }
+
     public static IAbpApplicationWithExternalServiceProvider AddApplication<TStartupModule>(
         [NotNull] this WebAssemblyHostBuilder builder,
         Action<AbpWebAssemblyApplicationCreationOptions> options)
@@ -51,7 +75,7 @@ public static class AbpWebAssemblyHostBuilderExtensions
         ((ComponentsClientScopeServiceProviderAccessor)serviceProvider
             .GetRequiredService<IClientScopeServiceProviderAccessor>()).ServiceProvider = serviceProvider;
 
-        application.Initialize(serviceProvider);
+        await application.InitializeAsync(serviceProvider);
         await InitializeModulesAsync(serviceProvider);
         await SetCurrentLanguageAsync(serviceProvider);
     }

framework/src/Volo.Abp.AspNetCore.TestBase/Volo/Abp/AspNetCore/TestBase/AbpAspNetCoreAsyncIntegratedTestBase.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting.Server;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.AspNetCore.TestBase;
+
+public class AbpAspNetCoreAsyncIntegratedTestBase<TModule>
+    where TModule : IAbpModule
+{
+    protected WebApplication WebApplication { get; set; }
+
+    protected TestServer Server { get; set; }
+
+    protected HttpClient Client { get; set; }
+
+    protected IServiceProvider ServiceProvider { get; set; }
+
+    protected virtual T GetService<T>()
+    {
+        return ServiceProvider.GetService<T>();
+    }
+
+    protected virtual T GetRequiredService<T>()
+    {
+        return ServiceProvider.GetRequiredService<T>();
+    }
+
+    public virtual async Task InitializeAsync()
+    {
+        var builder = WebApplication.CreateBuilder();
+        builder.Host.ConfigureServices(services =>
+            {
+                services.AddSingleton<IHostLifetime, TestNoopHostLifetime>();
+                services.AddSingleton<IServer, TestServer>();
+            })
+            .UseAutofac();
+
+        await builder.Services.AddApplicationAsync<TModule>(options =>
+        {
+            options.Services.ReplaceConfiguration(builder.Configuration);
+        });
+
+        await ConfigureServicesAsync(builder.Services);
+        WebApplication = builder.Build();
+        await WebApplication.InitializeApplicationAsync();
+        await WebApplication.StartAsync();
+
+        Server = WebApplication.Services.GetRequiredService<IHost>().GetTestServer();
+        Client = Server.CreateClient();
+
+        ServiceProvider = Server.Services;
+        ServiceProvider.GetRequiredService<ITestServerAccessor>().Server = Server;
+    }
+
+    public virtual async Task DisposeAsync()
+    {
+        await WebApplication.DisposeAsync();
+    }
+
+    protected virtual Task ConfigureServicesAsync(IServiceCollection services)
+    {
+        return Task.CompletedTask;
+    }
+
+    #region GetUrl
+
+    /// <summary>
+    /// Gets default URL for given controller type.
+    /// </summary>
+    /// <typeparam name="TController">The type of the controller.</typeparam>
+    protected virtual string GetUrl<TController>()
+    {
+        return "/" + typeof(TController).Name.RemovePostFix("Controller", "AppService", "ApplicationService", "Service");
+    }
+
+    /// <summary>
+    /// Gets default URL for given controller type's given action.
+    /// </summary>
+    /// <typeparam name="TController">The type of the controller.</typeparam>
+    protected virtual string GetUrl<TController>(string actionName)
+    {
+        return GetUrl<TController>() + "/" + actionName;
+    }
+
+    /// <summary>
+    /// Gets default URL for given controller type's given action with query string parameters (as anonymous object).
+    /// </summary>
+    /// <typeparam name="TController">The type of the controller.</typeparam>
+    protected virtual string GetUrl<TController>(string actionName, object queryStringParamsAsAnonymousObject)
+    {
+        var url = GetUrl<TController>(actionName);
+
+        var dictionary = new RouteValueDictionary(queryStringParamsAsAnonymousObject);
+        if (dictionary.Any())
+        {
+            url += "?" + dictionary.Select(d => $"{d.Key}={d.Value}").JoinAsString("&");
+        }
+
+        return url;
+    }
+
+    #endregion
+}

framework/src/Volo.Abp.AspNetCore.TestBase/Volo/Abp/AspNetCore/TestBase/AbpAspNetCoreIntegratedTestBase.cs

@@ -17,8 +17,6 @@ public abstract class AbpAspNetCoreIntegratedTestBase<TStartup> : AbpTestBaseWit
 
     protected HttpClient Client { get; }
 
-    protected override IServiceProvider ServiceProvider { get; }
-
     private readonly IHost _host;
 
     protected AbpAspNetCoreIntegratedTestBase()

framework/src/Volo.Abp.AspNetCore.TestBase/Volo/Abp/AspNetCore/TestBase/TestNoopHostLifetime.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+
+namespace Volo.Abp.AspNetCore.TestBase;
+
+public class TestNoopHostLifetime : IHostLifetime
+{
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+
+    public Task WaitForStartAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+}

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/Builder/AbpApplicationBuilderExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.AspNetCore.RequestLocalization;
 using Microsoft.Extensions.DependencyInjection;
@@ -11,6 +12,7 @@ using Volo.Abp.AspNetCore.Security.Claims;
 using Volo.Abp.AspNetCore.Tracing;
 using Volo.Abp.AspNetCore.Uow;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Threading;
 
 namespace Microsoft.AspNetCore.Builder;
 
@@ -18,6 +20,27 @@ public static class AbpApplicationBuilderExtensions
 {
     private const string ExceptionHandlingMiddlewareMarker = "_AbpExceptionHandlingMiddleware_Added";
 
+    public async static Task InitializeApplicationAsync([NotNull] this IApplicationBuilder app)
+    {
+        Check.NotNull(app, nameof(app));
+
+        app.ApplicationServices.GetRequiredService<ObjectAccessor<IApplicationBuilder>>().Value = app;
+        var application = app.ApplicationServices.GetRequiredService<IAbpApplicationWithExternalServiceProvider>();
+        var applicationLifetime = app.ApplicationServices.GetRequiredService<IHostApplicationLifetime>();
+
+        applicationLifetime.ApplicationStopping.Register(() =>
+        {
+            AsyncHelper.RunSync(() => application.ShutdownAsync());
+        });
+
+        applicationLifetime.ApplicationStopped.Register(() =>
+        {
+            application.Dispose();
+        });
+
+        await application.InitializeAsync(app.ApplicationServices);
+    }
+
     public static void InitializeApplication([NotNull] this IApplicationBuilder app)
     {
         Check.NotNull(app, nameof(app));

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/AbpBackgroundJobsRabbitMqModule.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.Modularity;
 using Volo.Abp.RabbitMQ;
 using Volo.Abp.Threading;
@@ -17,31 +18,37 @@ public class AbpBackgroundJobsRabbitMqModule : AbpModule
         context.Services.AddSingleton(typeof(IJobQueue<>), typeof(JobQueue<>));
     }
 
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        await StartJobQueueManagerAsync(context);
+    }
+
+    public async override Task OnApplicationShutdownAsync(ApplicationShutdownContext context)
+    {
+        await StopJobQueueManagerAsync(context);
+    }
+
     public override void OnApplicationInitialization(ApplicationInitializationContext context)
     {
-        StartJobQueueManager(context);
+        AsyncHelper.RunSync(() => StartJobQueueManagerAsync(context));
     }
 
     public override void OnApplicationShutdown(ApplicationShutdownContext context)
     {
-        StopJobQueueManager(context);
+        AsyncHelper.RunSync(() => StopJobQueueManagerAsync(context));
     }
 
-    private static void StartJobQueueManager(ApplicationInitializationContext context)
+    private async static Task StartJobQueueManagerAsync(ApplicationInitializationContext context)
     {
-        AsyncHelper.RunSync(
-            () => context.ServiceProvider
-                .GetRequiredService<IJobQueueManager>()
-                .StartAsync()
-        );
+        await context.ServiceProvider
+            .GetRequiredService<IJobQueueManager>()
+            .StartAsync();
     }
 
-    private static void StopJobQueueManager(ApplicationShutdownContext context)
+    private async static Task StopJobQueueManagerAsync(ApplicationShutdownContext context)
     {
-        AsyncHelper.RunSync(
-            () => context.ServiceProvider
-                .GetRequiredService<IJobQueueManager>()
-                .StopAsync()
-        );
+        await context.ServiceProvider
+            .GetRequiredService<IJobQueueManager>()
+            .StopAsync();
     }
 }

framework/src/Volo.Abp.BackgroundJobs/Volo/Abp/BackgroundJobs/AbpBackgroundJobsModule.cs

@@ -1,9 +1,11 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Volo.Abp.BackgroundWorkers;
 using Volo.Abp.DistributedLocking;
 using Volo.Abp.Guids;
 using Volo.Abp.Modularity;
+using Volo.Abp.Threading;
 using Volo.Abp.Timing;
 
 namespace Volo.Abp.BackgroundJobs;
@@ -17,12 +19,21 @@ namespace Volo.Abp.BackgroundJobs;
     )]
 public class AbpBackgroundJobsModule : AbpModule
 {
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        var options = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundJobOptions>>().Value;
+        if (options.IsJobExecutionEnabled)
+        {
+            await context.AddBackgroundWorkerAsync<IBackgroundJobWorker>();
+        }
+    }
+
     public override void OnApplicationInitialization(ApplicationInitializationContext context)
     {
         var options = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundJobOptions>>().Value;
         if (options.IsJobExecutionEnabled)
         {
-            context.AddBackgroundWorker<IBackgroundJobWorker>();
+            AsyncHelper.RunSync(() => context.AddBackgroundWorkerAsync<IBackgroundJobWorker>());
         }
     }
 }

framework/src/Volo.Abp.BackgroundWorkers.Hangfire/Volo/Abp/BackgroundWorkers/Hangfire/HangfireBackgroundWorkerManager.cs

@@ -21,7 +21,7 @@ public class HangfireBackgroundWorkerManager : IBackgroundWorkerManager, ISingle
         return Task.CompletedTask;
     }
 
-    public void Add(IBackgroundWorker worker)
+    public async Task AddAsync(IBackgroundWorker worker)
     {
         if (worker is IHangfireBackgroundWorker hangfireBackgroundWorker)
         {

framework/src/Volo.Abp.BackgroundWorkers.Quartz/Volo/Abp/BackgroundWorkers/Quartz/AbpBackgroundWorkersQuartzModule.cs

@@ -5,6 +5,7 @@ using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Options;
 using Volo.Abp.Modularity;
 using Volo.Abp.Quartz;
+using Volo.Abp.Threading;
 
 namespace Volo.Abp.BackgroundWorkers.Quartz;
 
@@ -34,6 +35,21 @@ public class AbpBackgroundWorkersQuartzModule : AbpModule
         }
     }
 
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        var quartzBackgroundWorkerOptions = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundWorkerQuartzOptions>>().Value;
+        if (quartzBackgroundWorkerOptions.IsAutoRegisterEnabled)
+        {
+            var backgroundWorkerManager = context.ServiceProvider.GetRequiredService<IBackgroundWorkerManager>();
+            var works = context.ServiceProvider.GetServices<IQuartzBackgroundWorker>().Where(x => x.AutoRegister);
+
+            foreach (var work in works)
+            {
+                await backgroundWorkerManager.AddAsync(work);
+            }
+        }
+    }
+
     public override void OnApplicationInitialization(ApplicationInitializationContext context)
     {
         var quartzBackgroundWorkerOptions = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundWorkerQuartzOptions>>().Value;
@@ -44,7 +60,7 @@ public class AbpBackgroundWorkersQuartzModule : AbpModule
 
             foreach (var work in works)
             {
-                backgroundWorkerManager.Add(work);
+                AsyncHelper.RunSync(() => backgroundWorkerManager.AddAsync(work));
             }
         }
     }

framework/src/Volo.Abp.BackgroundWorkers.Quartz/Volo/Abp/BackgroundWorkers/Quartz/QuartzBackgroundWorkerManager.cs

@@ -33,9 +33,9 @@ public class QuartzBackgroundWorkerManager : IBackgroundWorkerManager, ISingleto
         }
     }
 
-    public virtual void Add(IBackgroundWorker worker)
+    public virtual async Task AddAsync(IBackgroundWorker worker)
     {
-        AsyncHelper.RunSync(() => ReScheduleJobAsync(worker));
+        await ReScheduleJobAsync(worker);
     }
 
     protected virtual async Task ReScheduleJobAsync(IBackgroundWorker worker)

framework/src/Volo.Abp.BackgroundWorkers/Volo/Abp/BackgroundWorkers/AbpBackgroundWorkersModule.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Volo.Abp.Modularity;
 using Volo.Abp.Threading;
@@ -10,6 +11,28 @@ namespace Volo.Abp.BackgroundWorkers;
     )]
 public class AbpBackgroundWorkersModule : AbpModule
 {
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        var options = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundWorkerOptions>>().Value;
+        if (options.IsEnabled)
+        {
+            await context.ServiceProvider
+                .GetRequiredService<IBackgroundWorkerManager>()
+                .StartAsync();
+        }
+    }
+
+    public async override Task OnApplicationShutdownAsync(ApplicationShutdownContext context)
+    {
+        var options = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundWorkerOptions>>().Value;
+        if (options.IsEnabled)
+        {
+            await context.ServiceProvider
+                .GetRequiredService<IBackgroundWorkerManager>()
+                .StopAsync();
+        }
+    }
+
     public override void OnApplicationInitialization(ApplicationInitializationContext context)
     {
         var options = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundWorkerOptions>>().Value;

framework/src/Volo.Abp.BackgroundWorkers/Volo/Abp/BackgroundWorkers/BackgroundWorkerManager.cs

@@ -26,15 +26,13 @@ public class BackgroundWorkerManager : IBackgroundWorkerManager, ISingletonDepen
         _backgroundWorkers = new List<IBackgroundWorker>();
     }
 
-    public virtual void Add(IBackgroundWorker worker)
+    public virtual async Task AddAsync(IBackgroundWorker worker)
     {
         _backgroundWorkers.Add(worker);
 
         if (IsRunning)
         {
-            AsyncHelper.RunSync(
-                () => worker.StartAsync()
-            );
+            await worker.StartAsync();
         }
     }
 

framework/src/Volo.Abp.BackgroundWorkers/Volo/Abp/BackgroundWorkers/BackgroundWorkersApplicationInitializationContextExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -6,17 +7,17 @@ namespace Volo.Abp.BackgroundWorkers;
 
 public static class BackgroundWorkersApplicationInitializationContextExtensions
 {
-    public static ApplicationInitializationContext AddBackgroundWorker<TWorker>([NotNull] this ApplicationInitializationContext context)
+    public async static Task<ApplicationInitializationContext> AddBackgroundWorkerAsync<TWorker>([NotNull] this ApplicationInitializationContext context)
         where TWorker : IBackgroundWorker
     {
         Check.NotNull(context, nameof(context));
 
-        context.AddBackgroundWorker(typeof(TWorker));
+        await context.AddBackgroundWorkerAsync(typeof(TWorker));
 
         return context;
     }
 
-    public static ApplicationInitializationContext AddBackgroundWorker([NotNull] this ApplicationInitializationContext context, [NotNull] Type workerType)
+    public async static Task<ApplicationInitializationContext> AddBackgroundWorkerAsync([NotNull] this ApplicationInitializationContext context, [NotNull] Type workerType)
     {
         Check.NotNull(context, nameof(context));
         Check.NotNull(workerType, nameof(workerType));
@@ -26,9 +27,9 @@ public static class BackgroundWorkersApplicationInitializationContextExtensions
             throw new AbpException($"Given type ({workerType.AssemblyQualifiedName}) must implement the {typeof(IBackgroundWorker).AssemblyQualifiedName} interface, but it doesn't!");
         }
 
-        context.ServiceProvider
+        await context.ServiceProvider
             .GetRequiredService<IBackgroundWorkerManager>()
-            .Add(
+            .AddAsync(
                 (IBackgroundWorker)context.ServiceProvider.GetRequiredService(workerType)
             );
 

framework/src/Volo.Abp.BackgroundWorkers/Volo/Abp/BackgroundWorkers/IBackgroundWorkerManager.cs

@@ -1,4 +1,5 @@
-using Volo.Abp.Threading;
+using System.Threading.Tasks;
+using Volo.Abp.Threading;
 
 namespace Volo.Abp.BackgroundWorkers;
 
@@ -13,5 +14,5 @@ public interface IBackgroundWorkerManager : IRunnable
     /// <param name="worker">
     /// The worker. It should be resolved from IOC.
     /// </param>
-    void Add(IBackgroundWorker worker);
+    Task AddAsync(IBackgroundWorker worker);
 }

framework/src/Volo.Abp.Core/Microsoft/Extensions/DependencyInjection/ServiceCollectionApplicationExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Volo.Abp;
 using Volo.Abp.Modularity;
@@ -22,4 +23,20 @@ public static class ServiceCollectionApplicationExtensions
     {
         return AbpApplicationFactory.Create(startupModuleType, services, optionsAction);
     }
+
+    public async static Task<IAbpApplicationWithExternalServiceProvider> AddApplicationAsync<TStartupModule>(
+        [NotNull] this IServiceCollection services,
+        [CanBeNull] Action<AbpApplicationCreationOptions> optionsAction = null)
+        where TStartupModule : IAbpModule
+    {
+        return await AbpApplicationFactory.CreateAsync<TStartupModule>(services,  optionsAction);
+    }
+
+    public async static Task<IAbpApplicationWithExternalServiceProvider> AddApplicationAsync(
+        [NotNull] this IServiceCollection services,
+        [NotNull] Type startupModuleType,
+        [CanBeNull] Action<AbpApplicationCreationOptions> optionsAction = null)
+    {
+        return await AbpApplicationFactory.CreateAsync(startupModuleType, services, optionsAction);
+    }
 }

framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationBase.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -23,6 +24,8 @@ public abstract class AbpApplicationBase : IAbpApplication
 
     public IReadOnlyList<IAbpModuleDescriptor> Modules { get; }
 
+    private bool _configuredServices;
+
     internal AbpApplicationBase(
         [NotNull] Type startupModuleType,
         [NotNull] IServiceCollection services,
@@ -46,7 +49,21 @@ public abstract class AbpApplicationBase : IAbpApplication
         services.AddCoreAbpServices(this, options);
 
         Modules = LoadModules(services, options);
-        ConfigureServices();
+
+        if (!options.SkipConfigureServices)
+        {
+            ConfigureServices();
+        }
+    }
+
+    public virtual async Task ShutdownAsync()
+    {
+        using (var scope = ServiceProvider.CreateScope())
+        {
+            await scope.ServiceProvider
+                .GetRequiredService<IModuleManager>()
+                .ShutdownModulesAsync(new ApplicationShutdownContext(scope.ServiceProvider));
+        }
     }
 
     public virtual void Shutdown()
@@ -70,6 +87,17 @@ public abstract class AbpApplicationBase : IAbpApplication
         ServiceProvider.GetRequiredService<ObjectAccessor<IServiceProvider>>().Value = ServiceProvider;
     }
 
+    protected virtual async Task InitializeModulesAsync()
+    {
+        using (var scope = ServiceProvider.CreateScope())
+        {
+            WriteInitLogs(scope.ServiceProvider);
+            await scope.ServiceProvider
+                .GetRequiredService<IModuleManager>()
+                .InitializeModulesAsync(new ApplicationInitializationContext(scope.ServiceProvider));
+        }
+    }
+
     protected virtual void InitializeModules()
     {
         using (var scope = ServiceProvider.CreateScope())
@@ -111,8 +139,99 @@ public abstract class AbpApplicationBase : IAbpApplication
     }
 
     //TODO: We can extract a new class for this
-    protected virtual void ConfigureServices()
+    public virtual async Task ConfigureServicesAsync()
+    {
+        CheckMultipleConfigureServices();
+        
+        var context = new ServiceConfigurationContext(Services);
+        Services.AddSingleton(context);
+
+        foreach (var module in Modules)
+        {
+            if (module.Instance is AbpModule abpModule)
+            {
+                abpModule.ServiceConfigurationContext = context;
+            }
+        }
+
+        //PreConfigureServices
+        foreach (var module in Modules.Where(m => m.Instance is IPreConfigureServices))
+        {
+            try
+            {
+                await ((IPreConfigureServices)module.Instance).PreConfigureServicesAsync(context);
+            }
+            catch (Exception ex)
+            {
+                throw new AbpInitializationException($"An error occurred during {nameof(IPreConfigureServices.PreConfigureServicesAsync)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
+            }
+        }
+
+        var assemblies = new HashSet<Assembly>();
+
+        //ConfigureServices
+        foreach (var module in Modules)
+        {
+            if (module.Instance is AbpModule abpModule)
+            {
+                if (!abpModule.SkipAutoServiceRegistration)
+                {
+                    var assembly = module.Type.Assembly;
+                    if (!assemblies.Contains(assembly))
+                    {
+                        Services.AddAssembly(assembly);
+                        assemblies.Add(assembly);
+                    }
+                }
+            }
+
+            try
+            {
+                await module.Instance.ConfigureServicesAsync(context);
+            }
+            catch (Exception ex)
+            {
+                throw new AbpInitializationException($"An error occurred during {nameof(IAbpModule.ConfigureServicesAsync)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
+            }
+        }
+
+        //PostConfigureServices
+        foreach (var module in Modules.Where(m => m.Instance is IPostConfigureServices))
+        {
+            try
+            {
+                await ((IPostConfigureServices)module.Instance).PostConfigureServicesAsync(context);
+            }
+            catch (Exception ex)
+            {
+                throw new AbpInitializationException($"An error occurred during {nameof(IPostConfigureServices.PostConfigureServicesAsync)} phase of the module {module.Type.AssemblyQualifiedName}. See the inner exception for details.", ex);
+            }
+        }
+
+        foreach (var module in Modules)
+        {
+            if (module.Instance is AbpModule abpModule)
+            {
+                abpModule.ServiceConfigurationContext = null;
+            }
+        }
+
+        _configuredServices = true;
+    }
+
+    private void CheckMultipleConfigureServices()
+    {
+        if (_configuredServices)
+        {
+            throw new AbpInitializationException("Services have already been configured! If you call ConfigureServicesAsync method, you must have set AbpApplicationCreationOptions.SkipConfigureServices tu true before.");
+        }
+    }
+
+    //TODO: We can extract a new class for this
+    public virtual void ConfigureServices()
     {
+        CheckMultipleConfigureServices();
+        
         var context = new ServiceConfigurationContext(Services);
         Services.AddSingleton(context);
 
@@ -185,5 +304,7 @@ public abstract class AbpApplicationBase : IAbpApplication
                 abpModule.ServiceConfigurationContext = null;
             }
         }
+
+        _configuredServices = true;
     }
 }

framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationCreationOptions.cs

@@ -19,6 +19,8 @@ public class AbpApplicationCreationOptions
     [NotNull]
     public AbpConfigurationBuilderOptions Configuration { get; }
 
+    public bool SkipConfigureServices { get; set; }
+
     public AbpApplicationCreationOptions([NotNull] IServiceCollection services)
     {
         Services = Check.NotNull(services, nameof(services));

framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationFactory.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.Modularity;
@@ -7,6 +8,60 @@ namespace Volo.Abp;
 
 public static class AbpApplicationFactory
 {
+    public async static Task<IAbpApplicationWithInternalServiceProvider> CreateAsync<TStartupModule>(
+        [CanBeNull] Action<AbpApplicationCreationOptions> optionsAction = null)
+        where TStartupModule : IAbpModule
+    {
+        var app = Create(typeof(TStartupModule), options =>
+        {
+            optionsAction?.Invoke(options);
+            options.SkipConfigureServices = true;
+        });
+        await app.ConfigureServicesAsync();
+        return app;
+    }
+
+    public async static Task<IAbpApplicationWithInternalServiceProvider> CreateAsync(
+        [NotNull] Type startupModuleType,
+        [CanBeNull] Action<AbpApplicationCreationOptions> optionsAction = null)
+    {
+        var app = new AbpApplicationWithInternalServiceProvider(startupModuleType, options =>
+        {
+            optionsAction?.Invoke(options);
+            options.SkipConfigureServices = true;
+        });
+        await app.ConfigureServicesAsync();
+        return app;
+    }
+
+    public async static Task<IAbpApplicationWithExternalServiceProvider> CreateAsync<TStartupModule>(
+        [NotNull] IServiceCollection services,
+        [CanBeNull] Action<AbpApplicationCreationOptions> optionsAction = null)
+        where TStartupModule : IAbpModule
+    {
+        var app = Create(typeof(TStartupModule), services, options =>
+        {
+            optionsAction?.Invoke(options);
+            options.SkipConfigureServices = true;
+        });
+        await app.ConfigureServicesAsync();
+        return app;
+    }
+
+    public async static Task<IAbpApplicationWithExternalServiceProvider> CreateAsync(
+        [NotNull] Type startupModuleType,
+        [NotNull] IServiceCollection services,
+        [CanBeNull] Action<AbpApplicationCreationOptions> optionsAction = null)
+    {
+        var app = new AbpApplicationWithExternalServiceProvider(startupModuleType, services, options =>
+        {
+            optionsAction?.Invoke(options);
+            options.SkipConfigureServices = true;
+        });
+        await app.ConfigureServicesAsync();
+        return app;
+    }
+
     public static IAbpApplicationWithInternalServiceProvider Create<TStartupModule>(
         [CanBeNull] Action<AbpApplicationCreationOptions> optionsAction = null)
         where TStartupModule : IAbpModule

framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationWithExternalServiceProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -35,6 +36,15 @@ internal class AbpApplicationWithExternalServiceProvider : AbpApplicationBase, I
         SetServiceProvider(serviceProvider);
     }
 
+    public async Task InitializeAsync(IServiceProvider serviceProvider)
+    {
+        Check.NotNull(serviceProvider, nameof(serviceProvider));
+
+        SetServiceProvider(serviceProvider);
+
+        await InitializeModulesAsync();
+    }
+
     public void Initialize([NotNull] IServiceProvider serviceProvider)
     {
         Check.NotNull(serviceProvider, nameof(serviceProvider));

framework/src/Volo.Abp.Core/Volo/Abp/AbpApplicationWithInternalServiceProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -44,6 +45,12 @@ internal class AbpApplicationWithInternalServiceProvider : AbpApplicationBase, I
         return ServiceProvider;
     }
 
+    public async Task InitializeAsync()
+    {
+        CreateServiceProvider();
+        await InitializeModulesAsync();
+    }
+
     public void Initialize()
     {
         CreateServiceProvider();

framework/src/Volo.Abp.Core/Volo/Abp/IAbpApplication.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.Modularity;
 
@@ -22,6 +23,18 @@ public interface IAbpApplication : IModuleContainer, IDisposable
     /// This can not be used before initialize the application.
     /// </summary>
     IServiceProvider ServiceProvider { get; }
+    
+    /// <summary>
+    /// Calls the Pre/Post/ConfigureServicesAsync methods of the modules.
+    /// If you use this method, you must have set the <see cref="AbpApplicationCreationOptions.SkipConfigureServices"/>
+    /// option to true before.
+    /// </summary>
+    Task ConfigureServicesAsync();
+
+    /// <summary>
+    /// Used to gracefully shutdown the application and all modules.
+    /// </summary>
+    Task ShutdownAsync();
 
     /// <summary>
     /// Used to gracefully shutdown the application and all modules.

framework/src/Volo.Abp.Core/Volo/Abp/IAbpApplicationWithExternalServiceProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using JetBrains.Annotations;
 
 namespace Volo.Abp;
@@ -9,6 +10,13 @@ public interface IAbpApplicationWithExternalServiceProvider : IAbpApplication
     /// Sets the service provider, but not initializes the modules.
     /// </summary>
     void SetServiceProvider([NotNull] IServiceProvider serviceProvider);
+    
+    /// <summary>
+    /// Sets the service provider and initializes all the modules.
+    /// If <see cref="SetServiceProvider"/> was called before, the same
+    /// <see cref="serviceProvider"/> instance should be passed to this method.
+    /// </summary>
+    Task InitializeAsync([NotNull] IServiceProvider serviceProvider);
 
     /// <summary>
     /// Sets the service provider and initializes all the modules.

framework/src/Volo.Abp.Core/Volo/Abp/IAbpApplicationWithInternalServiceProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 
 namespace Volo.Abp;
 
@@ -10,6 +11,13 @@ public interface IAbpApplicationWithInternalServiceProvider : IAbpApplication
     /// </summary>
     IServiceProvider CreateServiceProvider();
 
+    /// <summary>
+    /// Creates the service provider and initializes all the modules.
+    /// If <see cref="CreateServiceProvider"/> method was called before,
+    /// it does not re-create it, but uses the previous one.
+    /// </summary>
+    Task InitializeAsync();
+
     /// <summary>
     /// Creates the service provider and initializes all the modules.
     /// If <see cref="CreateServiceProvider"/> method was called before,

framework/src/Volo.Abp.Core/Volo/Abp/IOnApplicationInitialization.cs

@@ -1,8 +1,11 @@
-using JetBrains.Annotations;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp;
 
 public interface IOnApplicationInitialization
 {
+    Task OnApplicationInitializationAsync([NotNull] ApplicationInitializationContext context);
+
     void OnApplicationInitialization([NotNull] ApplicationInitializationContext context);
 }

framework/src/Volo.Abp.Core/Volo/Abp/IOnApplicationShutdown.cs

@@ -1,8 +1,11 @@
-using JetBrains.Annotations;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp;
 
 public interface IOnApplicationShutdown
 {
+    Task OnApplicationShutdownAsync([NotNull] ApplicationShutdownContext context);
+
     void OnApplicationShutdown([NotNull] ApplicationShutdownContext context);
 }

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

@@ -1,5 +1,6 @@
 using System;
 using System.Reflection;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -30,36 +31,78 @@ public abstract class AbpModule :
 
     private ServiceConfigurationContext _serviceConfigurationContext;
 
+    public virtual Task PreConfigureServicesAsync(ServiceConfigurationContext context)
+    {
+        PreConfigureServices(context);
+        return Task.CompletedTask;
+    }
+
     public virtual void PreConfigureServices(ServiceConfigurationContext context)
     {
 
     }
 
+    public virtual Task ConfigureServicesAsync(ServiceConfigurationContext context)
+    {
+        ConfigureServices(context);
+        return Task.CompletedTask;
+    }
+
     public virtual void ConfigureServices(ServiceConfigurationContext context)
     {
 
     }
 
+    public virtual Task PostConfigureServicesAsync(ServiceConfigurationContext context)
+    {
+        PostConfigureServices(context);
+        return Task.CompletedTask;
+    }
+
     public virtual void PostConfigureServices(ServiceConfigurationContext context)
     {
 
     }
 
+    public virtual Task OnPreApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        OnPreApplicationInitialization(context);
+        return Task.CompletedTask;
+    }
+
     public virtual void OnPreApplicationInitialization(ApplicationInitializationContext context)
     {
 
     }
 
+    public virtual Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        OnApplicationInitialization(context);
+        return Task.CompletedTask;
+    }
+
     public virtual void OnApplicationInitialization(ApplicationInitializationContext context)
     {
 
     }
 
+    public virtual Task OnPostApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        OnPostApplicationInitialization(context);
+        return Task.CompletedTask;
+    }
+
     public virtual void OnPostApplicationInitialization(ApplicationInitializationContext context)
     {
 
     }
 
+    public virtual Task OnApplicationShutdownAsync(ApplicationShutdownContext context)
+    {
+        OnApplicationShutdown(context);
+        return Task.CompletedTask;
+    }
+
     public virtual void OnApplicationShutdown(ApplicationShutdownContext context)
     {
 

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/DefaultModuleLifecycleContributor.cs

@@ -1,7 +1,17 @@
-namespace Volo.Abp.Modularity;
+using System.Threading.Tasks;
+
+namespace Volo.Abp.Modularity;
 
 public class OnApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
 {
+    public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
+    {
+        if (module is IOnApplicationInitialization onApplicationInitialization)
+        {
+            await onApplicationInitialization.OnApplicationInitializationAsync(context);
+        }
+    }
+
     public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
     {
         (module as IOnApplicationInitialization)?.OnApplicationInitialization(context);
@@ -10,6 +20,14 @@ public class OnApplicationInitializationModuleLifecycleContributor : ModuleLifec
 
 public class OnApplicationShutdownModuleLifecycleContributor : ModuleLifecycleContributorBase
 {
+    public async override Task ShutdownAsync(ApplicationShutdownContext context, IAbpModule module)
+    {
+        if (module is IOnApplicationShutdown onApplicationShutdown)
+        {
+            await onApplicationShutdown.OnApplicationShutdownAsync(context);
+        }
+    }
+
     public override void Shutdown(ApplicationShutdownContext context, IAbpModule module)
     {
         (module as IOnApplicationShutdown)?.OnApplicationShutdown(context);
@@ -18,6 +36,14 @@ public class OnApplicationShutdownModuleLifecycleContributor : ModuleLifecycleCo
 
 public class OnPreApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
 {
+    public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
+    {
+        if (module is IOnPreApplicationInitialization onPreApplicationInitialization)
+        {
+            await onPreApplicationInitialization.OnPreApplicationInitializationAsync(context);
+        }
+    }
+
     public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
     {
         (module as IOnPreApplicationInitialization)?.OnPreApplicationInitialization(context);
@@ -26,6 +52,14 @@ public class OnPreApplicationInitializationModuleLifecycleContributor : ModuleLi
 
 public class OnPostApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
 {
+    public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
+    {
+        if (module is IOnPostApplicationInitialization onPostApplicationInitialization)
+        {
+            await onPostApplicationInitialization.OnPostApplicationInitializationAsync(context);
+        }
+    }
+
     public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
     {
         (module as IOnPostApplicationInitialization)?.OnPostApplicationInitialization(context);

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/IAbpModule.cs

@@ -1,6 +1,10 @@
-namespace Volo.Abp.Modularity;
+using System.Threading.Tasks;
+
+namespace Volo.Abp.Modularity;
 
 public interface IAbpModule
 {
+    Task ConfigureServicesAsync(ServiceConfigurationContext context);
+
     void ConfigureServices(ServiceConfigurationContext context);
 }

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/IModuleLifecycleContributor.cs

@@ -1,11 +1,16 @@
-using JetBrains.Annotations;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
 using Volo.Abp.DependencyInjection;
 
 namespace Volo.Abp.Modularity;
 
 public interface IModuleLifecycleContributor : ITransientDependency
 {
+    Task InitializeAsync([NotNull] ApplicationInitializationContext context, [NotNull] IAbpModule module);
+
     void Initialize([NotNull] ApplicationInitializationContext context, [NotNull] IAbpModule module);
 
+    Task ShutdownAsync([NotNull] ApplicationShutdownContext context, [NotNull] IAbpModule module);
+
     void Shutdown([NotNull] ApplicationShutdownContext context, [NotNull] IAbpModule module);
 }

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/IModuleManager.cs

@@ -1,10 +1,15 @@
-using JetBrains.Annotations;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp.Modularity;
 
 public interface IModuleManager
 {
+    Task InitializeModulesAsync([NotNull] ApplicationInitializationContext context);
+
     void InitializeModules([NotNull] ApplicationInitializationContext context);
 
+    Task ShutdownModulesAsync([NotNull] ApplicationShutdownContext context);
+
     void ShutdownModules([NotNull] ApplicationShutdownContext context);
 }

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/IOnPostApplicationInitialization.cs

@@ -1,8 +1,11 @@
-using JetBrains.Annotations;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp.Modularity;
 
 public interface IOnPostApplicationInitialization
 {
+    Task OnPostApplicationInitializationAsync([NotNull] ApplicationInitializationContext context);
+
     void OnPostApplicationInitialization([NotNull] ApplicationInitializationContext context);
 }

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/IOnPreApplicationInitialization.cs

@@ -1,8 +1,11 @@
-using JetBrains.Annotations;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
 
 namespace Volo.Abp.Modularity;
 
 public interface IOnPreApplicationInitialization
 {
+    Task OnPreApplicationInitializationAsync([NotNull] ApplicationInitializationContext context);
+
     void OnPreApplicationInitialization([NotNull] ApplicationInitializationContext context);
 }

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/IPostConfigureServices.cs

@@ -1,8 +1,10 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
 
 namespace Volo.Abp.Modularity;
 
 public interface IPostConfigureServices
 {
+    Task PostConfigureServicesAsync(ServiceConfigurationContext context);
+
     void PostConfigureServices(ServiceConfigurationContext context);
 }

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/IPreConfigureServices.cs

@@ -1,8 +1,10 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
 
 namespace Volo.Abp.Modularity;
 
 public interface IPreConfigureServices
 {
+    Task PreConfigureServicesAsync(ServiceConfigurationContext context);
+
     void PreConfigureServices(ServiceConfigurationContext context);
 }

framework/src/Volo.Abp.Core/Volo/Abp/Modularity/ModuleLifecycleContributorBase.cs

@@ -1,11 +1,23 @@
-namespace Volo.Abp.Modularity;
+using System.Threading.Tasks;
+
+namespace Volo.Abp.Modularity;
 
 public abstract class ModuleLifecycleContributorBase : IModuleLifecycleContributor
 {
+    public virtual Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
+    {
+        return Task.CompletedTask;
+    }
+
     public virtual void Initialize(ApplicationInitializationContext context, IAbpModule module)
     {
     }
 
+    public virtual Task ShutdownAsync(ApplicationShutdownContext context, IAbpModule module)
+    {
+        return Task.CompletedTask;
+    }
+
     public virtual void Shutdown(ApplicationShutdownContext context, IAbpModule module)
     {
     }

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -30,6 +31,26 @@ public class ModuleManager : IModuleManager, ISingletonDependency
             .ToArray();
     }
 
+    public virtual async Task InitializeModulesAsync(ApplicationInitializationContext context)
+    {
+        foreach (var contributor in _lifecycleContributors)
+        {
+            foreach (var module in _moduleContainer.Modules)
+            {
+                try
+                {
+                    await contributor.InitializeAsync(context, module.Instance);
+                }
+                catch (Exception ex)
+                {
+                    throw new AbpInitializationException($"An error occurred during the initialize {contributor.GetType().FullName} phase of the module {module.Type.AssemblyQualifiedName}: {ex.Message}. See the inner exception for details.", ex);
+                }
+            }
+        }
+
+        _logger.LogInformation("Initialized all ABP modules.");
+    }
+
     public void InitializeModules(ApplicationInitializationContext context)
     {
         foreach (var contributor in _lifecycleContributors)
@@ -50,6 +71,26 @@ public class ModuleManager : IModuleManager, ISingletonDependency
         _logger.LogInformation("Initialized all ABP modules.");
     }
 
+    public virtual async Task ShutdownModulesAsync(ApplicationShutdownContext context)
+    {
+        var modules = _moduleContainer.Modules.Reverse().ToList();
+
+        foreach (var contributor in _lifecycleContributors)
+        {
+            foreach (var module in modules)
+            {
+                try
+                {
+                    await contributor.ShutdownAsync(context, module.Instance);
+                }
+                catch (Exception ex)
+                {
+                    throw new AbpShutdownException($"An error occurred during the shutdown {contributor.GetType().FullName} phase of the module {module.Type.AssemblyQualifiedName}: {ex.Message}. See the inner exception for details.", ex);
+                }
+            }
+        }
+    }
+
     public void ShutdownModules(ApplicationShutdownContext context)
     {
         var modules = _moduleContainer.Modules.Reverse().ToList();

framework/src/Volo.Abp.EventBus/Volo/Abp/EventBus/AbpEventBusModule.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using Volo.Abp.BackgroundWorkers;
 using Volo.Abp.DistributedLocking;
 using Volo.Abp.EventBus.Abstractions;
@@ -12,6 +13,7 @@ using Volo.Abp.Json;
 using Volo.Abp.Modularity;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.Reflection;
+using Volo.Abp.Threading;
 
 namespace Volo.Abp.EventBus;
 
@@ -30,10 +32,16 @@ public class AbpEventBusModule : AbpModule
         AddEventHandlers(context.Services);
     }
 
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        await context.AddBackgroundWorkerAsync<OutboxSenderManager>();
+        await context.AddBackgroundWorkerAsync<InboxProcessManager>();
+    }
+
     public override void OnApplicationInitialization(ApplicationInitializationContext context)
     {
-        context.AddBackgroundWorker<OutboxSenderManager>();
-        context.AddBackgroundWorker<InboxProcessManager>();
+        AsyncHelper.RunSync(() => context.AddBackgroundWorkerAsync<OutboxSenderManager>());
+        AsyncHelper.RunSync(() => context.AddBackgroundWorkerAsync<InboxProcessManager>());
     }
 
     private static void AddEventHandlers(IServiceCollection services)

framework/src/Volo.Abp.Quartz/Volo/Abp/Quartz/AbpQuartzModule.cs

@@ -1,8 +1,8 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Quartz;
 using Quartz.Impl;
-using Quartz.Impl.AdoJobStore.Common;
 using Volo.Abp.Modularity;
 using Volo.Abp.Threading;
 
@@ -18,8 +18,8 @@ public class AbpQuartzModule : AbpModule
 
         context.Services.AddQuartz(options.Properties, build =>
         {
-                // these are the defaults
-                if (options.Properties[StdSchedulerFactory.PropertySchedulerJobFactoryType] == null)
+            // these are the defaults
+            if (options.Properties[StdSchedulerFactory.PropertySchedulerJobFactoryType] == null)
             {
                 build.UseMicrosoftDependencyInjectionScopedJobFactory();
             }
@@ -62,6 +62,23 @@ public class AbpQuartzModule : AbpModule
         });
     }
 
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        var options = context.ServiceProvider.GetRequiredService<IOptions<AbpQuartzOptions>>().Value;
+
+        _scheduler = context.ServiceProvider.GetRequiredService<IScheduler>();
+
+        await options.StartSchedulerFactory.Invoke(_scheduler);
+    }
+
+    public async override Task OnApplicationShutdownAsync(ApplicationShutdownContext context)
+    {
+        if (_scheduler.IsStarted)
+        {
+            await _scheduler.Shutdown();
+        }
+    }
+
     public override void OnApplicationInitialization(ApplicationInitializationContext context)
     {
         var options = context.ServiceProvider.GetRequiredService<IOptions<AbpQuartzOptions>>().Value;

framework/src/Volo.Abp.TestBase/Volo/Abp/AbpTestBaseWithServiceProvider.cs

@@ -5,7 +5,7 @@ namespace Volo.Abp;
 
 public abstract class AbpTestBaseWithServiceProvider
 {
-    protected abstract IServiceProvider ServiceProvider { get; }
+    protected IServiceProvider ServiceProvider { get; set; }
 
     protected virtual T GetService<T>()
     {

framework/src/Volo.Abp.TestBase/Volo/Abp/Testing/AbpAsyncIntegratedTest.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Testing;
+
+public class AbpAsyncIntegratedTest<TStartupModule> : AbpTestBaseWithServiceProvider
+    where TStartupModule : IAbpModule
+{
+    protected IAbpApplication Application { get; set; }
+
+    protected IServiceProvider RootServiceProvider { get; set; }
+
+    protected IServiceScope TestServiceScope { get; set; }
+
+    public virtual async Task InitializeAsync()
+    {
+        var services = await CreateServiceCollectionAsync();
+
+        await BeforeAddApplicationAsync(services);
+        var application = await services.AddApplicationAsync<TStartupModule>(await SetAbpApplicationCreationOptionsAsync());
+        await AfterAddApplicationAsync(services);
+
+        RootServiceProvider = await CreateServiceProviderAsync(services);
+        TestServiceScope = RootServiceProvider.CreateScope();
+        await application.InitializeAsync(TestServiceScope.ServiceProvider);
+        ServiceProvider = application.ServiceProvider;
+        Application = application;
+
+        await InitializeServicesAsync();
+    }
+
+    public virtual async Task DisposeAsync()
+    {
+        await Application.ShutdownAsync();
+        TestServiceScope.Dispose();
+        Application.Dispose();
+    }
+
+    protected virtual Task<IServiceCollection> CreateServiceCollectionAsync()
+    {
+        return Task.FromResult<IServiceCollection>(new ServiceCollection());
+    }
+
+    protected virtual Task BeforeAddApplicationAsync(IServiceCollection services)
+    {
+        return Task.CompletedTask;
+    }
+
+    protected virtual Task<Action<AbpApplicationCreationOptions>> SetAbpApplicationCreationOptionsAsync()
+    {
+        return Task.FromResult<Action<AbpApplicationCreationOptions>>(_ => { });
+    }
+
+    protected virtual Task AfterAddApplicationAsync(IServiceCollection services)
+    {
+        return Task.CompletedTask;
+    }
+
+    protected virtual Task<IServiceProvider> CreateServiceProviderAsync(IServiceCollection services)
+    {
+        return Task.FromResult(services.BuildServiceProviderFromFactory());
+    }
+
+    protected virtual Task InitializeServicesAsync()
+    {
+        return Task.CompletedTask;
+    }
+}

framework/src/Volo.Abp.TestBase/Volo/Abp/Testing/AbpIntegratedTest.cs

@@ -9,8 +9,6 @@ public abstract class AbpIntegratedTest<TStartupModule> : AbpTestBaseWithService
 {
     protected IAbpApplication Application { get; }
 
-    protected override IServiceProvider ServiceProvider => Application.ServiceProvider;
-
     protected IServiceProvider RootServiceProvider { get; }
 
     protected IServiceScope TestServiceScope { get; }
@@ -30,6 +28,7 @@ public abstract class AbpIntegratedTest<TStartupModule> : AbpTestBaseWithService
         TestServiceScope = RootServiceProvider.CreateScope();
 
         application.Initialize(TestServiceScope.ServiceProvider);
+        ServiceProvider = Application.ServiceProvider;
     }
 
     protected virtual IServiceCollection CreateServiceCollection()

framework/test/Volo.Abp.AspNetCore.Mvc.Tests/Volo/Abp/AspNetCore/Mvc/AbpAspNetCoreAsyncTestBase_Tests.cs

@@ -0,0 +1,62 @@
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Volo.Abp.AspNetCore.TestBase;
+using Volo.Abp.Autofac;
+using Volo.Abp.Modularity;
+using Xunit;
+
+namespace Volo.Abp.AspNetCore.Mvc;
+
+public class AbpAspNetCoreAsyncTestBase_Tests : AbpAspNetCoreAsyncTestBase<AbpAspNetCoreAsyncTestModule>
+{
+    [Fact]
+    public async Task Get_API_Response_Test()
+    {
+        var result = await GetResponseAsStringAsync("/api");
+        result.ShouldBe(await GetRequiredService<DataBaseService>().GetResponseAsync());
+    }
+}
+
+[DependsOn(
+    typeof(AbpAspNetCoreMvcModule),
+    typeof(AbpAspNetCoreTestBaseModule),
+    typeof(AbpAutofacModule)
+)]
+public class AbpAspNetCoreAsyncTestModule : AbpModule
+{
+    public override Task ConfigureServicesAsync(ServiceConfigurationContext context)
+    {
+        context.Services.AddTransient<DataBaseService>();
+        return Task.CompletedTask;
+    }
+
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        var app = context.GetApplicationBuilder();
+
+        var dataBaseService = app.ApplicationServices.GetRequiredService<DataBaseService>();
+
+        var apiResponse = await dataBaseService.GetResponseAsync();
+        app.Map("/api", _ =>
+        {
+            app.Run(async httpContext =>
+            {
+                await httpContext.Response.WriteAsync(apiResponse);
+            });
+        });
+
+        app.UseRouting();
+        app.UseConfiguredEndpoints();
+    }
+}
+
+public class DataBaseService
+{
+    public Task<string> GetResponseAsync()
+    {
+        return Task.FromResult("hello api!");
+    }
+}

framework/test/Volo.Abp.AspNetCore.Tests/Volo/Abp/AspNetCore/AbpAspNetCoreAsyncTestBase.cs

@@ -0,0 +1,45 @@
+using System.Globalization;
+using System.Net;
+using System.Net.Http;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Net.Http.Headers;
+using Shouldly;
+using Volo.Abp.AspNetCore.TestBase;
+using Volo.Abp.Modularity;
+using Xunit;
+
+namespace Volo.Abp.AspNetCore;
+
+public abstract class AbpAspNetCoreAsyncTestBase<TModule> : AbpAspNetCoreAsyncIntegratedTestBase<TModule>, IAsyncLifetime
+    where TModule : AbpModule
+{
+    protected virtual async Task<T> GetResponseAsObjectAsync<T>(string url, HttpStatusCode expectedStatusCode = HttpStatusCode.OK)
+    {
+        var strResponse = await GetResponseAsStringAsync(url, expectedStatusCode);
+        return JsonSerializer.Deserialize<T>(strResponse, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
+    }
+
+    protected virtual async Task<string> GetResponseAsStringAsync(string url, HttpStatusCode expectedStatusCode = HttpStatusCode.OK)
+    {
+        using (var response = await GetResponseAsync(url, expectedStatusCode))
+        {
+            return await response.Content.ReadAsStringAsync();
+        }
+    }
+
+    protected virtual async Task<HttpResponseMessage> GetResponseAsync(string url, HttpStatusCode expectedStatusCode = HttpStatusCode.OK, bool xmlHttpRequest = false)
+    {
+        using (var requestMessage = new HttpRequestMessage(HttpMethod.Get, url))
+        {
+            requestMessage.Headers.Add("Accept-Language", CultureInfo.CurrentUICulture.Name);
+            if (xmlHttpRequest)
+            {
+                requestMessage.Headers.Add(HeaderNames.XRequestedWith, "XMLHttpRequest");
+            }
+            var response = await Client.SendAsync(requestMessage);
+            response.StatusCode.ShouldBe(expectedStatusCode);
+            return response;
+        }
+    }
+}

framework/test/Volo.Abp.Autofac.Tests/Volo/Abp/Autofac/Interception/Autofac_Interception_Test.cs

@@ -1,11 +1,13 @@
-using Volo.Abp.DynamicProxy;
+using System;
+using System.Threading.Tasks;
+using Volo.Abp.DynamicProxy;
 
 namespace Volo.Abp.Autofac.Interception;
 
 public class Autofac_Interception_Test : AbpInterceptionTestBase<AutofacTestModule>
 {
-    protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+    protected override Task<Action<AbpApplicationCreationOptions>> SetAbpApplicationCreationOptionsAsync()
     {
-        options.UseAutofac();
+        return Task.FromResult<Action<AbpApplicationCreationOptions>>(options => options.UseAutofac());
     }
 }

framework/test/Volo.Abp.Core.Tests/Volo/Abp/AbpApplication_Initialize_Tests.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Shouldly;
 using Volo.Abp.Modularity;
 using Volo.Abp.Modularity.PlugIns;
@@ -8,6 +9,39 @@ namespace Volo.Abp;
 
 public class AbpApplication_Initialize_Tests
 {
+    [Fact]
+    public async Task Should_Initialize_Single_Module_Async()
+    {
+        using (var application = await AbpApplicationFactory.CreateAsync<IndependentEmptyModule>())
+        {
+            //Assert
+            var module = application.Services.GetSingletonInstance<IndependentEmptyModule>();
+
+            module.PreConfigureServicesAsyncIsCalled.ShouldBeTrue();
+            module.PreConfigureServicesIsCalled.ShouldBeTrue();
+
+            module.ConfigureServicesAsyncIsCalled.ShouldBeTrue();
+            module.ConfigureServicesIsCalled.ShouldBeTrue();
+
+            module.PostConfigureServicesAsyncIsCalled.ShouldBeTrue();
+            module.PostConfigureServicesIsCalled.ShouldBeTrue();
+
+            //Act
+            await application.InitializeAsync();
+
+            //Assert
+            application.ServiceProvider.GetRequiredService<IndependentEmptyModule>().ShouldBeSameAs(module);
+            module.OnApplicationInitializeAsyncIsCalled.ShouldBeTrue();
+            module.OnApplicationInitializeIsCalled.ShouldBeTrue();
+            //Act
+            await application.ShutdownAsync();
+
+            //Assert
+            module.OnApplicationShutdownAsyncIsCalled.ShouldBeTrue();
+            module.OnApplicationShutdownIsCalled.ShouldBeTrue();
+        }
+    }
+
     [Fact]
     public void Should_Initialize_Single_Module()
     {
@@ -34,6 +68,50 @@ public class AbpApplication_Initialize_Tests
         }
     }
 
+    [Fact]
+    public async Task Should_Initialize_PlugIn_Async()
+    {
+        using (var application = await AbpApplicationFactory.CreateAsync<IndependentEmptyModule>(options =>
+               {
+                   options.PlugInSources.AddTypes(typeof(IndependentEmptyPlugInModule));
+               }))
+        {
+            //Assert
+            var plugInModule = application.Services.GetSingletonInstance<IndependentEmptyPlugInModule>();
+
+            plugInModule.PreConfigureServicesAsyncIsCalled.ShouldBeTrue();
+            plugInModule.PreConfigureServicesIsCalled.ShouldBeTrue();
+
+            plugInModule.ConfigureServicesAsyncIsCalled.ShouldBeTrue();
+            plugInModule.ConfigureServicesIsCalled.ShouldBeTrue();
+
+            plugInModule.PostConfigureServicesAsyncIsCalled.ShouldBeTrue();
+            plugInModule.PostConfigureServicesIsCalled.ShouldBeTrue();
+
+            //Act
+            await application.InitializeAsync();
+
+            //Assert
+            application.ServiceProvider.GetRequiredService<IndependentEmptyPlugInModule>().ShouldBeSameAs(plugInModule);
+
+            plugInModule.OnPreApplicationInitializationAsyncIsCalled.ShouldBeTrue();
+            plugInModule.OnPreApplicationInitializationIsCalled.ShouldBeTrue();
+
+            plugInModule.OnApplicationInitializeAsyncIsCalled.ShouldBeTrue();
+            plugInModule.OnApplicationInitializeIsCalled.ShouldBeTrue();
+
+            plugInModule.OnPostApplicationInitializationAsyncIsCalled.ShouldBeTrue();
+            plugInModule.OnPostApplicationInitializationIsCalled.ShouldBeTrue();
+
+            //Act
+            await application.ShutdownAsync();
+
+            //Assert
+            plugInModule.OnApplicationShutdownAsyncIsCalled.ShouldBeTrue();
+            plugInModule.OnApplicationShutdownIsCalled.ShouldBeTrue();
+        }
+    }
+
     [Fact]
     public void Should_Initialize_PlugIn()
     {
@@ -53,7 +131,9 @@ public class AbpApplication_Initialize_Tests
 
             //Assert
             application.ServiceProvider.GetRequiredService<IndependentEmptyPlugInModule>().ShouldBeSameAs(plugInModule);
+            plugInModule.OnPreApplicationInitializationIsCalled.ShouldBeTrue();
             plugInModule.OnApplicationInitializeIsCalled.ShouldBeTrue();
+            plugInModule.OnPostApplicationInitializationIsCalled.ShouldBeTrue();
 
             //Act
             application.Shutdown();

framework/test/Volo.Abp.Core.Tests/Volo/Abp/Configuration/ConfigurationAccessor_Tests.cs

@@ -1,4 +1,5 @@
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Shouldly;
 using Volo.Abp.Modularity;
@@ -8,6 +9,22 @@ namespace Volo.Abp.Configuration;
 
 public class ConfigurationAccessor_Tests
 {
+    [Fact]
+    public async Task Should_Use_Empty_ConfigurationRoot_By_Default_Async()
+    {
+        using (var application = await AbpApplicationFactory.CreateAsync<IndependentEmptyModule>())
+        {
+            var configuration1 = application.Services.GetConfiguration();
+            configuration1.ShouldNotBeNull();
+
+            await application.InitializeAsync();
+
+            var configuration2 = ResolveConfiguration(application);
+
+            configuration2.ShouldBe(configuration1);
+        }
+    }
+
     [Fact]
     public void Should_Use_Empty_ConfigurationRoot_By_Default()
     {
@@ -24,6 +41,23 @@ public class ConfigurationAccessor_Tests
         }
     }
 
+    [Fact]
+    public async Task Should_Use_The_Registered_ConfigurationRoot_Async()
+    {
+        using (var application = await AbpApplicationFactory.CreateAsync<IndependentEmptyModule>())
+        {
+            var myConfiguration = new ConfigurationBuilder().Build();
+            application.Services.ReplaceConfiguration(myConfiguration);
+            application.Services.GetConfiguration().ShouldBe(myConfiguration);
+
+            await application.InitializeAsync();
+
+            var configuration = ResolveConfiguration(application);
+
+            configuration.ShouldBe(myConfiguration);
+        }
+    }
+
     [Fact]
     public void Should_Use_The_Registered_ConfigurationRoot()
     {

framework/test/Volo.Abp.Core.Tests/Volo/Abp/DependencyInjection/AutoServiceRegistration_Tests.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Shouldly;
 using Volo.Abp.Modularity;
@@ -8,6 +9,20 @@ namespace Volo.Abp.DependencyInjection;
 
 public class AutoServiceRegistration_Tests
 {
+    [Fact]
+    public async Task AutoServiceRegistration_Should_Not_Duplicate_Test_Async()
+    {
+        using (var application = await AbpApplicationFactory.CreateAsync<TestModule>())
+        {
+            //Act
+            await application.InitializeAsync();
+
+            //Assert
+            var services = application.ServiceProvider.GetServices<TestService>().ToList();
+            services.Count.ShouldBe(1);
+        }
+    }
+
     [Fact]
     public void AutoServiceRegistration_Should_Not_Duplicate_Test()
     {

framework/test/Volo.Abp.Core.Tests/Volo/Abp/DependencyInjection/HybridServiceScopeFactory_Tests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Shouldly;
 using Volo.Abp.Modularity;
@@ -8,6 +9,26 @@ namespace Volo.Abp.DependencyInjection;
 
 public class HybridServiceScopeFactory_Tests
 {
+    [Fact]
+    public async Task Should_Use_Default_ServiceScopeFactory_By_Default_Async()
+    {
+        using (var application = await AbpApplicationFactory.CreateAsync<IndependentEmptyModule>())
+        {
+            application.Services.AddType(typeof(MyServiceAsync));
+
+            await application.InitializeAsync();
+
+            var serviceScopeFactory = application.ServiceProvider.GetRequiredService<IHybridServiceScopeFactory>();
+
+            using (var scope = serviceScopeFactory.CreateScope())
+            {
+                scope.ServiceProvider.GetRequiredService<MyServiceAsync>();
+            }
+
+            MyServiceAsync.DisposeCount.ShouldBe(1);
+        }
+    }
+
     [Fact]
     public void Should_Use_Default_ServiceScopeFactory_By_Default()
     {
@@ -28,6 +49,16 @@ public class HybridServiceScopeFactory_Tests
         }
     }
 
+    private class MyServiceAsync : ITransientDependency, IDisposable
+    {
+        public static int DisposeCount { get; private set; }
+
+        public void Dispose()
+        {
+            ++DisposeCount;
+        }
+    }
+
     private class MyService : ITransientDependency, IDisposable
     {
         public static int DisposeCount { get; private set; }

framework/test/Volo.Abp.Core.Tests/Volo/Abp/DynamicProxy/AbpInterceptionTestBase.cs

@@ -7,10 +7,10 @@ using Xunit;
 
 namespace Volo.Abp.DynamicProxy;
 
-public abstract class AbpInterceptionTestBase<TStartupModule> : AbpIntegratedTest<TStartupModule>
+public abstract class AbpInterceptionTestBase<TStartupModule> : AbpAsyncIntegratedTest<TStartupModule>, IAsyncLifetime
     where TStartupModule : IAbpModule
 {
-    protected override void BeforeAddApplication(IServiceCollection services)
+    protected override Task BeforeAddApplicationAsync(IServiceCollection services)
     {
         services.AddTransient<SimpleAsyncInterceptor>();
         services.AddTransient<SimpleAsyncInterceptor2>();
@@ -32,6 +32,8 @@ public abstract class AbpInterceptionTestBase<TStartupModule> : AbpIntegratedTes
                 registration.Interceptors.Add<SimpleResultCacheTestInterceptor>();
             }
         });
+
+        return Task.CompletedTask;
     }
 
     [Fact]

framework/test/Volo.Abp.Core.Tests/Volo/Abp/Modularity/TestModuleBase.cs

@@ -1,39 +1,97 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
 
 namespace Volo.Abp.Modularity;
 
 public class TestModuleBase : AbpModule
 {
-    public bool PreConfigureServicesIsCalled { get; set; }
+    public bool PreConfigureServicesAsyncIsCalled { get; set; }
+    public bool ConfigureServicesAsyncIsCalled { get; set; }
+    public bool PostConfigureServicesAsyncIsCalled { get; set; }
+    public bool OnPreApplicationInitializationIsCalled { get; set; }
+    public bool OnPostApplicationInitializationIsCalled { get; set; }
+    public bool OnApplicationInitializeAsyncIsCalled { get; set; }
+    public bool OnApplicationShutdownAsyncIsCalled { get; set; }
 
+    public bool PreConfigureServicesIsCalled { get; set; }
     public bool ConfigureServicesIsCalled { get; set; }
-
     public bool PostConfigureServicesIsCalled { get; set; }
-
+    public bool OnPreApplicationInitializationAsyncIsCalled { get; set; }
+    public bool OnPostApplicationInitializationAsyncIsCalled { get; set; }
     public bool OnApplicationInitializeIsCalled { get; set; }
-
     public bool OnApplicationShutdownIsCalled { get; set; }
 
+    public override Task PreConfigureServicesAsync(ServiceConfigurationContext context)
+    {
+        PreConfigureServicesAsyncIsCalled = true;
+        return base.PreConfigureServicesAsync(context);
+    }
+
     public override void PreConfigureServices(ServiceConfigurationContext context)
     {
         PreConfigureServicesIsCalled = true;
     }
 
+    public override Task ConfigureServicesAsync(ServiceConfigurationContext context)
+    {
+        ConfigureServicesAsyncIsCalled = true;
+        return base.ConfigureServicesAsync(context);
+    }
+
     public override void ConfigureServices(ServiceConfigurationContext context)
     {
         ConfigureServicesIsCalled = true;
     }
 
+    public override Task PostConfigureServicesAsync(ServiceConfigurationContext context)
+    {
+        PostConfigureServicesAsyncIsCalled = true;
+        return base.PostConfigureServicesAsync(context);
+    }
+
     public override void PostConfigureServices(ServiceConfigurationContext context)
     {
         PostConfigureServicesIsCalled = true;
     }
 
+    public override Task OnPreApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        OnPreApplicationInitializationAsyncIsCalled = true;
+        return base.OnPreApplicationInitializationAsync(context);
+    }
+
+    public override void OnPreApplicationInitialization(ApplicationInitializationContext context)
+    {
+        OnPreApplicationInitializationIsCalled = true;
+    }
+
+    public override Task OnPostApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        OnPostApplicationInitializationAsyncIsCalled = true;
+        return base.OnPostApplicationInitializationAsync(context);
+    }
+
+    public override void OnPostApplicationInitialization(ApplicationInitializationContext context)
+    {
+        OnPostApplicationInitializationIsCalled = true;
+    }
+
+    public override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+    {
+        OnApplicationInitializeAsyncIsCalled = true;
+        return base.OnApplicationInitializationAsync(context);
+    }
+
     public override void OnApplicationInitialization(ApplicationInitializationContext context)
     {
         OnApplicationInitializeIsCalled = true;
     }
 
+    public override Task OnApplicationShutdownAsync(ApplicationShutdownContext context)
+    {
+        OnApplicationShutdownAsyncIsCalled = true;
+        return base.OnApplicationShutdownAsync(context);
+    }
+
     public override void OnApplicationShutdown(ApplicationShutdownContext context)
     {
         OnApplicationShutdownIsCalled = true;

modules/docs/src/Volo.Docs.Domain/Volo/Docs/DocsDomainModule.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Volo.Abp;
@@ -39,7 +40,7 @@ namespace Volo.Docs
                 options.EtoMappings.Add<Document, DocumentEto>(typeof(DocsDomainModule));
                 options.EtoMappings.Add<Project, ProjectEto>(typeof(DocsDomainModule));
             });
-            
+
             Configure<AbpVirtualFileSystemOptions>(options =>
             {
                 options.FileSets
@@ -65,6 +66,18 @@ namespace Volo.Docs
             });
         }
 
+        public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
+        {
+            using (var scope = context.ServiceProvider.CreateScope())
+            {
+                if (scope.ServiceProvider.GetRequiredService<IOptions<DocsElasticSearchOptions>>().Value.Enable)
+                {
+                    var documentFullSearch = scope.ServiceProvider.GetRequiredService<IDocumentFullSearch>();
+                    await documentFullSearch.CreateIndexIfNeededAsync();
+                }
+            }
+        }
+
         public override void OnApplicationInitialization(ApplicationInitializationContext context)
         {
             using (var scope = context.ServiceProvider.CreateScope())

modules/identityserver/src/Volo.Abp.IdentityServer.Domain/Volo/Abp/IdentityServer/AbpIdentityServerDomainModule.cs

@@ -1,4 +1,5 @@
-using IdentityServer4.Services;
+using System.Threading.Tasks;
+using IdentityServer4.Services;
 using IdentityServer4.Stores;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -133,17 +134,31 @@ public class AbpIdentityServerDomainModule : AbpModule
         });
     }
 
-    public override void OnApplicationInitialization(ApplicationInitializationContext context)
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
     {
         var options = context.ServiceProvider.GetRequiredService<IOptions<TokenCleanupOptions>>().Value;
         if (options.IsCleanupEnabled)
         {
-            context.ServiceProvider
+            await context.ServiceProvider
                 .GetRequiredService<IBackgroundWorkerManager>()
-                .Add(
+                .AddAsync(
                     context.ServiceProvider
                         .GetRequiredService<TokenCleanupBackgroundWorker>()
                 );
         }
     }
+
+    public override void OnApplicationInitialization(ApplicationInitializationContext context)
+    {
+        var options = context.ServiceProvider.GetRequiredService<IOptions<TokenCleanupOptions>>().Value;
+        if (options.IsCleanupEnabled)
+        {
+            AsyncHelper.RunSync(() => context.ServiceProvider
+                .GetRequiredService<IBackgroundWorkerManager>()
+                .AddAsync(
+                    context.ServiceProvider
+                        .GetRequiredService<TokenCleanupBackgroundWorker>()
+                ));
+        }
+    }
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server.Tiered/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName.Blazor.Server.Tiered;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameBlazorModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    public static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server.Tiered/Startup.cs

@@ -1,18 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace MyCompanyName.MyProjectName.Blazor.Server.Tiered;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameBlazorModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
-    {
-        app.InitializeApplication();
-    }
-}

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName.Blazor.Server;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameBlazorModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    public static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor.Server/Startup.cs

@@ -1,18 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace MyCompanyName.MyProjectName.Blazor.Server;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameBlazorModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
-    {
-        app.InitializeApplication();
-    }
-}

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Blazor/Program.cs

@@ -5,11 +5,11 @@ namespace MyCompanyName.MyProjectName.Blazor;
 
 public class Program
 {
-    public static async Task Main(string[] args)
+    public async static Task Main(string[] args)
     {
         var builder = WebAssemblyHostBuilder.CreateDefault(args);
 
-        var application = builder.AddApplication<MyProjectNameBlazorModule>(options =>
+        var application = await builder.AddApplicationAsync<MyProjectNameBlazorModule>(options =>
         {
             options.UseAutofac();
         });

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.HttpApi.Host/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting MyCompanyName.MyProjectName.HttpApi.Host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameHttpApiHostModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.HttpApi.Host/Startup.cs

@@ -1,19 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace MyCompanyName.MyProjectName;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameHttpApiHostModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
-    {
-        app.InitializeApplication();
-    }
-}

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.HttpApi.HostWithIds/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting MyCompanyName.MyProjectName.HttpApi.Host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameHttpApiHostModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.HttpApi.HostWithIds/Startup.cs

@@ -1,19 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace MyCompanyName.MyProjectName;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameHttpApiHostModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
-    {
-        app.InitializeApplication();
-    }
-}

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.IdentityServer/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting MyCompanyName.MyProjectName.IdentityServer.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameIdentityServerModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.IdentityServer/Startup.cs

@@ -1,17 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace MyCompanyName.MyProjectName;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameIdentityServerModule>();
-    }
-
-    public void Configure(IApplicationBuilder app)
-    {
-        app.InitializeApplication();
-    }
-}

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Web.Host/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName.Web;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameWebModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Web.Host/Startup.cs

@@ -1,18 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace MyCompanyName.MyProjectName.Web;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameWebModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
-    {
-        app.InitializeApplication();
-    }
-}

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Web/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName.Web;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameWebModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.Web/Startup.cs

@@ -1,17 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace MyCompanyName.MyProjectName.Web;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameWebModule>();
-    }
-
-    public void Configure(IApplicationBuilder app)
-    {
-        app.InitializeApplication();
-    }
-}

templates/console/src/MyCompanyName.MyProjectName/HelloWorldService.cs

@@ -1,12 +1,22 @@
-using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Volo.Abp.DependencyInjection;
 
 namespace MyCompanyName.MyProjectName;
 
 public class HelloWorldService : ITransientDependency
 {
-    public void SayHello()
+    public ILogger<HelloWorldService> Logger { get; set; }
+
+    public HelloWorldService()
+    {
+        Logger = NullLogger<HelloWorldService>.Instance;
+    }
+
+    public Task SayHelloAsync()
     {
-        Console.WriteLine("\tHello World!");
+        Logger.LogInformation("Hello World!");
+        return Task.CompletedTask;
     }
 }

templates/console/src/MyCompanyName.MyProjectName/MyCompanyName.MyProjectName.csproj

@@ -14,6 +14,7 @@
     <ItemGroup>
       <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.0" />
       <PackageReference Include="Serilog.Extensions.Hosting" Version="4.1.2" />
+      <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
       <PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" />
       <PackageReference Include="Serilog.Sinks.Console" Version="4.0.0" />
       <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />

templates/console/src/MyCompanyName.MyProjectName/MyProjectNameHostedService.cs

@@ -1,40 +1,46 @@
-using System;
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Serilog;
 using Volo.Abp;
 
 namespace MyCompanyName.MyProjectName;
 
 public class MyProjectNameHostedService : IHostedService
 {
-    private readonly IAbpApplicationWithExternalServiceProvider _application;
-    private readonly IServiceProvider _serviceProvider;
-    private readonly HelloWorldService _helloWorldService;
-
-    public MyProjectNameHostedService(
-        IAbpApplicationWithExternalServiceProvider application,
-        IServiceProvider serviceProvider,
-        HelloWorldService helloWorldService)
+    private IAbpApplicationWithInternalServiceProvider _abpApplication;
+
+    private readonly IConfiguration _configuration;
+    private readonly IHostEnvironment _hostEnvironment;
+
+    public MyProjectNameHostedService(IConfiguration configuration, IHostEnvironment hostEnvironment)
     {
-        _application = application;
-        _serviceProvider = serviceProvider;
-        _helloWorldService = helloWorldService;
+        _configuration = configuration;
+        _hostEnvironment = hostEnvironment;
     }
 
-    public Task StartAsync(CancellationToken cancellationToken)
+    public async Task StartAsync(CancellationToken cancellationToken)
     {
-        _application.Initialize(_serviceProvider);
+        _abpApplication =  await AbpApplicationFactory.CreateAsync<MyProjectNameModule>(options =>
+        {
+            options.Services.ReplaceConfiguration(_configuration);
+            options.Services.AddSingleton(_hostEnvironment);
+
+            options.UseAutofac();
+            options.Services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true));
+        });
 
-        _helloWorldService.SayHello();
+        await _abpApplication.InitializeAsync();
 
-        return Task.CompletedTask;
+        var helloWorldService = _abpApplication.ServiceProvider.GetRequiredService<HelloWorldService>();
+
+        await helloWorldService.SayHelloAsync();
     }
 
-    public Task StopAsync(CancellationToken cancellationToken)
+    public async Task StopAsync(CancellationToken cancellationToken)
     {
-        _application.Shutdown();
-
-        return Task.CompletedTask;
+        await _abpApplication.ShutdownAsync();
     }
 }

templates/console/src/MyCompanyName.MyProjectName/MyProjectNameModule.cs

@@ -1,5 +1,9 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Volo.Abp;
 using Volo.Abp.Autofac;
 using Volo.Abp.Modularity;
 
@@ -10,11 +14,15 @@ namespace MyCompanyName.MyProjectName;
 )]
 public class MyProjectNameModule : AbpModule
 {
-    public override void ConfigureServices(ServiceConfigurationContext context)
+    public override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
     {
-        var configuration = context.Services.GetConfiguration();
-        var hostEnvironment = context.Services.GetSingletonInstance<IHostEnvironment>();
+        var logger = context.ServiceProvider.GetRequiredService<ILogger<MyProjectNameModule>>();
+        var configuration = context.ServiceProvider.GetRequiredService<IConfiguration>();
+        logger.LogInformation($"MySettingName => {configuration["MySettingName"]}");
 
-        context.Services.AddHostedService<MyProjectNameHostedService>();
+        var hostEnvironment = context.ServiceProvider.GetRequiredService<IHostEnvironment>();
+        logger.LogInformation($"EnvironmentName => {hostEnvironment.EnvironmentName}");
+
+        return Task.CompletedTask;
     }
 }

templates/console/src/MyCompanyName.MyProjectName/Program.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
@@ -10,7 +9,7 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static async Task<int> Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
@@ -27,7 +26,14 @@ public class Program
         try
         {
             Log.Information("Starting console host.");
-            await CreateHostBuilder(args).RunConsoleAsync();
+
+            await Host.CreateDefaultBuilder(args)
+                .ConfigureServices(services =>
+                {
+                    services.AddHostedService<MyProjectNameHostedService>();
+                })
+                .RunConsoleAsync();
+
             return 0;
         }
         catch (Exception ex)
@@ -39,19 +45,5 @@ public class Program
         {
             Log.CloseAndFlush();
         }
-
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .UseAutofac()
-            .UseSerilog()
-            .ConfigureAppConfiguration((context, config) =>
-            {
-                    //setup your additional configuration sources
-                })
-            .ConfigureServices((hostContext, services) =>
-            {
-                services.AddApplication<MyProjectNameModule>();
-            });
 }

templates/console/src/MyCompanyName.MyProjectName/appsettings.json

@@ -1,3 +1,3 @@
 {
-
+  "MySettingName": "MySettingValue"
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Host/Program.cs

@@ -5,11 +5,11 @@ namespace MyCompanyName.MyProjectName.Blazor.Host;
 
 public class Program
 {
-    public static async Task Main(string[] args)
+    public async static Task Main(string[] args)
     {
         var builder = WebAssemblyHostBuilder.CreateDefault(args);
 
-        var application = builder.AddApplication<MyProjectNameBlazorHostModule>(options =>
+        var application = await builder.AddApplicationAsync<MyProjectNameBlazorHostModule>(options =>
         {
             options.UseAutofac();
         });

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Server.Host/MyProjectNameBlazorHostModule.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Net.Http;
+using System.Threading.Tasks;
 using Blazorise.Bootstrap5;
 using Blazorise.Icons.FontAwesome;
 using Microsoft.AspNetCore.Builder;
@@ -211,7 +212,7 @@ public class MyProjectNameBlazorHostModule : AbpModule
 #endif
     }
 
-    public override void OnApplicationInitialization(ApplicationInitializationContext context)
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
     {
         var env = context.GetEnvironment();
         var app = context.GetApplicationBuilder();
@@ -252,12 +253,9 @@ public class MyProjectNameBlazorHostModule : AbpModule
 
         using (var scope = context.ServiceProvider.CreateScope())
         {
-            AsyncHelper.RunSync(async () =>
-            {
-                await scope.ServiceProvider
-                    .GetRequiredService<IDataSeeder>()
-                    .SeedAsync();
-            });
+            await scope.ServiceProvider
+                .GetRequiredService<IDataSeeder>()
+                .SeedAsync();
         }
     }
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Server.Host/Program.cs

@@ -1,6 +1,7 @@
 using System;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -9,27 +10,37 @@ namespace MyCompanyName.MyProjectName.Blazor.Server.Host;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameBlazorHostModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,15 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    public static IHostBuilder CreateHostBuilder(string[] args) =>
-        Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Blazor.Server.Host/Startup.cs

@@ -1,18 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace MyCompanyName.MyProjectName.Blazor.Server.Host;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameBlazorHostModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
-    {
-        app.InitializeApplication();
-    }
-}

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.HttpApi.Host/Program.cs

@@ -1,7 +1,7 @@
 using System;
-using System.IO;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -10,26 +10,37 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameHttpApiHostModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.HttpApi.Host/Startup.cs

@@ -1,20 +0,0 @@
-using System;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace MyCompanyName.MyProjectName;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameHttpApiHostModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
-    {
-        app.InitializeApplication();
-    }
-}

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.IdentityServer/MyProjectNameIdentityServerModule.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.DataProtection;
@@ -187,7 +188,7 @@ public class MyProjectNameIdentityServerModule : AbpModule
 #endif
     }
 
-    public override void OnApplicationInitialization(ApplicationInitializationContext context)
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
     {
         var app = context.GetApplicationBuilder();
         var env = context.GetEnvironment();
@@ -227,19 +228,16 @@ public class MyProjectNameIdentityServerModule : AbpModule
         app.UseAbpSerilogEnrichers();
         app.UseConfiguredEndpoints();
 
-        SeedData(context);
+        await SeedData(context);
     }
 
-    private void SeedData(ApplicationInitializationContext context)
+    private async Task SeedData(ApplicationInitializationContext context)
     {
-        AsyncHelper.RunSync(async () =>
+        using (var scope = context.ServiceProvider.CreateScope())
         {
-            using (var scope = context.ServiceProvider.CreateScope())
-            {
-                await scope.ServiceProvider
-                    .GetRequiredService<IDataSeeder>()
-                    .SeedAsync();
-            }
-        });
+            await scope.ServiceProvider
+                .GetRequiredService<IDataSeeder>()
+                .SeedAsync();
+        }
     }
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.IdentityServer/Program.cs

@@ -1,7 +1,7 @@
 using System;
-using System.IO;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.Configuration;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -10,26 +10,37 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameIdentityServerModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +53,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.IdentityServer/Startup.cs

@@ -1,20 +0,0 @@
-using System;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace MyCompanyName.MyProjectName;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameIdentityServerModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
-    {
-        app.InitializeApplication();
-    }
-}

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Host/Program.cs

@@ -1,7 +1,10 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -10,26 +13,37 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameWebHostModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -42,14 +56,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Host/Startup.cs

@@ -1,18 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace MyCompanyName.MyProjectName;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameWebHostModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
-    {
-        app.InitializeApplication();
-    }
-}

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/MyProjectNameWebUnifiedModule.cs

@@ -1,5 +1,6 @@
 using System.IO;
 using System.Reflection;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -140,7 +141,7 @@ public class MyProjectNameWebUnifiedModule : AbpModule
 #endif
     }
 
-    public override void OnApplicationInitialization(ApplicationInitializationContext context)
+    public async override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
     {
         var app = context.GetApplicationBuilder();
         var env = context.GetEnvironment();
@@ -180,12 +181,9 @@ public class MyProjectNameWebUnifiedModule : AbpModule
 
         using (var scope = context.ServiceProvider.CreateScope())
         {
-            AsyncHelper.RunSync(async () =>
-            {
-                await scope.ServiceProvider
-                    .GetRequiredService<IDataSeeder>()
-                    .SeedAsync();
-            });
+            await scope.ServiceProvider
+                .GetRequiredService<IDataSeeder>()
+                .SeedAsync();
         }
     }
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/Program.cs

@@ -1,7 +1,10 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
@@ -10,22 +13,37 @@ namespace MyCompanyName.MyProjectName;
 
 public class Program
 {
-    public static int Main(string[] args)
+    public async static Task<int> Main(string[] args)
     {
         Log.Logger = new LoggerConfiguration()
+#if DEBUG
             .MinimumLevel.Debug()
+#else
+            .MinimumLevel.Information()
+#endif
             .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft.EntityFrameworkCore", LogEventLevel.Warning)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
 #if DEBUG
-                .WriteTo.Async(c => c.Console())
+            .WriteTo.Async(c => c.Console())
 #endif
-                .CreateLogger();
+            .CreateLogger();
 
         try
         {
             Log.Information("Starting web host.");
-            CreateHostBuilder(args).Build().Run();
+            var builder = WebApplication.CreateBuilder(args);
+            builder.Host.AddAppSettingsSecretsJson()
+                .UseAutofac()
+                .UseSerilog();
+            await builder.Services.AddApplicationAsync<MyProjectNameWebUnifiedModule>(options =>
+            {
+                options.Services.ReplaceConfiguration(builder.Configuration);
+            });
+            var app = builder.Build();
+            await app.InitializeApplicationAsync();
+            await app.RunAsync();
             return 0;
         }
         catch (Exception ex)
@@ -38,14 +56,4 @@ public class Program
             Log.CloseAndFlush();
         }
     }
-
-    internal static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .AddAppSettingsSecretsJson()
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            })
-            .UseAutofac()
-            .UseSerilog();
 }

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/Startup.cs

@@ -1,19 +0,0 @@
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace MyCompanyName.MyProjectName;
-
-public class Startup
-{
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddApplication<MyProjectNameWebUnifiedModule>();
-    }
-
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
-    {
-        app.InitializeApplication();
-    }
-}

templates/wpf/src/MyCompanyName.MyProjectName/App.xaml.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Windows;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
 using Serilog;
 using Serilog.Events;
 using Volo.Abp;
@@ -13,35 +12,34 @@ namespace MyCompanyName.MyProjectName;
 /// </summary>
 public partial class App : Application
 {
-    private readonly IHost _host;
-    private readonly IAbpApplicationWithExternalServiceProvider _application;
+    private IAbpApplicationWithInternalServiceProvider _abpApplication;
 
-    public App()
+    protected async override void OnStartup(StartupEventArgs e)
     {
         Log.Logger = new LoggerConfiguration()
 #if DEBUG
-                .MinimumLevel.Debug()
+            .MinimumLevel.Debug()
 #else
-                .MinimumLevel.Information()
+            .MinimumLevel.Information()
 #endif
-                .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
+            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
             .Enrich.FromLogContext()
             .WriteTo.Async(c => c.File("Logs/logs.txt"))
             .CreateLogger();
 
-        _host = CreateHostBuilder();
-        _application = _host.Services.GetService<IAbpApplicationWithExternalServiceProvider>();
-    }
-
-    protected override async void OnStartup(StartupEventArgs e)
-    {
         try
         {
             Log.Information("Starting WPF host.");
-            await _host.StartAsync();
-            Initialize(_host.Services);
 
-            _host.Services.GetService<MainWindow>()?.Show();
+            _abpApplication =  await AbpApplicationFactory.CreateAsync<MyProjectNameModule>(options =>
+            {
+                options.UseAutofac();
+                options.Services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true));
+            });
+
+            await _abpApplication.InitializeAsync();
+
+            _abpApplication.Services.GetRequiredService<MainWindow>()?.Show();
 
         }
         catch (Exception ex)
@@ -50,28 +48,9 @@ public partial class App : Application
         }
     }
 
-    protected override async void OnExit(ExitEventArgs e)
+    protected async override void OnExit(ExitEventArgs e)
     {
-        _application.Shutdown();
-        await _host.StopAsync();
-        _host.Dispose();
+        await _abpApplication.ShutdownAsync();
         Log.CloseAndFlush();
     }
-
-    private void Initialize(IServiceProvider serviceProvider)
-    {
-        _application.Initialize(serviceProvider);
-    }
-
-    private IHost CreateHostBuilder()
-    {
-        return Host
-            .CreateDefaultBuilder(null)
-            .UseAutofac()
-            .UseSerilog()
-            .ConfigureServices((hostContext, services) =>
-            {
-                services.AddApplication<MyProjectNameModule>();
-            }).Build();
-    }
 }

templates/wpf/src/MyCompanyName.MyProjectName/HelloWorldService.cs

@@ -1,11 +1,20 @@
-using Volo.Abp.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Volo.Abp.DependencyInjection;
 
 namespace MyCompanyName.MyProjectName;
 
 public class HelloWorldService : ITransientDependency
 {
+    public ILogger<HelloWorldService> Logger { get; set; }
+
+    public HelloWorldService()
+    {
+        Logger = NullLogger<HelloWorldService>.Instance;
+    }
     public string SayHello()
     {
-        return "\tHello world!";
+        Logger.LogInformation("Call SayHello");
+        return "Hello world!";
     }
 }

templates/wpf/src/MyCompanyName.MyProjectName/MyCompanyName.MyProjectName.csproj

@@ -15,6 +15,7 @@
     <ItemGroup>
         <PackageReference Include="Microsoft.Extensions.Hosting" Version="6.0.0" />
         <PackageReference Include="Serilog.Extensions.Hosting" Version="4.1.2" />
+        <PackageReference Include="Serilog.Extensions.Logging" Version="3.1.0" />
         <PackageReference Include="Serilog.Sinks.Async" Version="1.5.0" />
         <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
     </ItemGroup>