Merge pull request #10928 from abpframework/new-hosting-model

Use new hosting model for the app template.

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>