ABP VNext Series: Framework Startup Process and Dependency Injection Principles and Source Code Analysis

Introduction ABP VNext

Github Address:/abpframework/abp
Official Documentation Address:/docs/latest
Official website:/

• The ABP VNext framework is a complete Core-based infrastructure, which we now call the ABP framework, that follows software development best practices and the latest technologies to create modern Web applications and APIs.
• ABP vNext is a new project initiated by the authors of the ABP framework. The core library of the ABP vNext framework is more streamlined than the ABP framework, as many of the original components have been extracted from its core library into separate components. This allows developers to be more flexible in choosing the features they need for integration and keeps projects away from bloated libraries.
• ABP provides a complete, modular and layered software architecture based on domain-driven design principles and patterns. It also provides the infrastructure and guidance needed to realize this architecture.
• The ABP framework provides a number of features to more easily implement real-world scenarios, such as event buses, background operating systems, audit logs, BLOB storage, data seeding, data filtering, and more.

Framework Launch Process

Modular Documentation:/docs/latest/framework/architecture/modularity/basics

Download the source code:/abpframework/abp/tree/dev/framework

Refer to Building a Project for the new Core MVC:/docs/latest/get-started/empty-aspnet-core-application

    public class Program
    {
        public static async Task Main(string[] args)
        {
            var builder = (args);
            (); //RecommendedAutofacAs a dependency injection framework
            //pour intoABPRelated Services
            await <MCodeAbpWebModule>();
            var app = ();
            //initialization process
            await ();
            await ();
        }
    }


    /// <summary>
    /// What modules are needed to bring in what modules，才会pour into
    /// </summary>
    [DependsOn(
         typeof(AbpAspNetCoreMvcModule),
         typeof(AbpSwashbuckleModule),
         typeof(MCodeAbpApplicationModule),
         typeof(AbpAutofacModule)
        )]
    public class MCodeAbpWebModule : AbpModule
    {
        /// <summary>
        /// 将你的服务添加到依赖pour into系统并configure其他模块的
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override Task ConfigureServicesAsync(ServiceConfigurationContext context)
        {
            var service = ;

            //set upapispecification
            ();

            //dynamic (science)Api
            Configure<AbpAspNetCoreMvcOptions>(options =>
            {
                (typeof(MCodeAbpApplicationModule).Assembly, options => = "v1");
                //universal prefix (linguistics)
                (x => = "api/app");
            });

            ///configure Swagger
            (options =>
            {
                var serviceProvider = ();

                var mvcOptions = <IOptions<AbpAspNetCoreMvcOptions>>();

                var mvcSettings = (x => );

                ("v1", new OpenApiInfo { Title = "", Version = "v1", Description = "" });

                // Filter by group name API (computer) file(necessarily) *****
                ((docName, apiDesc) =>
                {
                    if ( is ControllerActionDescriptor controllerActionDescriptor)
                    {
                        var settingOrNull = (x => == ).FirstOrDefault();
                        if (settingOrNull is not null)
                        {
                            return docName == ;
                        }
                    }
                    return false;
                });

                //configure模型标识，default (setting),Same name，Different clear space will report an error，So change it toFullName,Add namespace distinction
                (type => );
            });

            return ;
        }

        /// <summary>
        /// Code execution at application startup
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public override Task OnApplicationInitializationAsync(ApplicationInitializationContext context)
        {
            var app = ();

            ();

            ();

            ();
            (c =>
            {
                ("/swagger/v1/", "");
            });

            ();

            return ;
        }
    }


    public class MCodeAbpApplicationModule : AbpModule
    {

    }

     /// <summary>
    ///Extended Example
    /// </summary>
    [Route("[controller]/[action]")]
    public class TestService : ApplicationService
    {
        /// <summary>
        /// dynamic (science)Api
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        [HttpGet]
        public string GetHelloWorld(string? name)
        {
            return name ?? "HelloWord";
        }
    }

source code analysis

Replacing the IOC Container

pass (a bill or inspection etc)UseServiceProviderFactory() method, which builds Abp's custom Autofac container factory, in effect making a layer of wrapping

public static class AbpAutofacHostBuilderExtensions
{
    public static IHostBuilder UseAutofac(this IHostBuilder hostBuilder)
    {
        //initializationAutoFacContainer Building Objects
        var containerBuilder = new ContainerBuilder();

        return ((_, services) =>
            {
                (containerBuilder);
            })
            //enrollmentAbpcustomizableAutofacContainer factory
            .UseServiceProviderFactory(new AbpAutofacServiceProviderFactory(containerBuilder));
    }
}

Adding ABP Applications

pass (a bill or inspection etc)AbpApplicationFactory Class Factory Create Startup Module Program

    public async static Task<IAbpApplicationWithExternalServiceProvider> AddApplicationAsync<TStartupModule>(
        [NotNull] this IServiceCollection services,
        Action<AbpApplicationCreationOptions>? optionsAction = null)
        where TStartupModule : IAbpModule
    {
        return await <TStartupModule>(services, optionsAction);
    }

    /// <summary>
    /// pass (a bill or inspection etc) AbpApplicationFactory establish ABP application
    /// </summary>
    /// <typeparam name="TStartupModule"></typeparam>
    /// <param name="services"></param>
    /// <param name="optionsAction"></param>
    /// <returns></returns>
    public async static Task<IAbpApplicationWithExternalServiceProvider> CreateAsync<TStartupModule>(
        [NotNull] IServiceCollection services,
        Action<AbpApplicationCreationOptions>? optionsAction = null)
        where TStartupModule : IAbpModule
    {
        var app = Create(typeof(TStartupModule), services, options =>
        {
             = true;
            optionsAction?.Invoke(options);
        });
        //Calling the Configuration Service
        await ();
        return app;
    }

Creating an ABP External Service Provider

AbpApplicationWithExternalServiceProvider The only thing the constructor does is add itself to the service.
The core is inherited fromAbpApplicationBase Base class, the constructor method of the base class will be called after instantiation.

    /// <summary>
    /// establish ABP　External service providers（Instantiating Application Base Classes）
    /// </summary>
    /// <param name="startupModuleType"></param>
    /// <param name="services"></param>
    /// <param name="optionsAction"></param>
    /// <returns></returns>
    public static IAbpApplicationWithExternalServiceProvider Create(
        [NotNull] Type startupModuleType,
        [NotNull] IServiceCollection services,
        Action<AbpApplicationCreationOptions>? optionsAction = null)
    {
        //will instantiateABPapplication base class
        return new AbpApplicationWithExternalServiceProvider(startupModuleType, services, optionsAction);
    }

Initialize the ABP program base class

The initialization action of the module is performed in theAbpApplicationBase The base class starts with a base class in which the infrastructure associated with the module is injected in addition to the base class.
It also defines the initialization method of the module, theLoadModules() method, inside of which is the call to theIModuleLoader To perform specific loading operations

/// <summary>
/// Initializing the Abp program
/// </summary>
/// <param name="startupModuleType"></param> /// <param name="startupModuleType" ></param>
/// <param name="services"></param> /// <param name="startupModuleType"></param>
/// <param name="optionsAction"></param>; /// <param name="services"></param>
internal AbpApplicationBase(
    [NotNull] Type startupModuleType, [NotNull] Type startupModuleType, [NotNull] IServiceApplicationBase(
    [NotNull] IServiceCollection services, [NotNull] Action<AbpApplicationBase(
    Action<AbpApplicationCreationOptions>? optionsAction)
{
    (startupModuleType, nameof(startupModuleType));;
    (services, nameof(services));;

    startupModuleType = startupModuleType; services = services; services, nameof(services))
    Services = services.

    <IServiceProvider>();

    var options = new AbpApplicationCreationOptions(services);
    // Add the Services to the configuration
    optionsAction?.Invoke(options);
    //Get the application name
    ApplicationName = GetApplicationName(options);

    // Add the current object as various service instances
    <IAbpApplication>(this);.
    <IApplicationInfoAccessor>(this);;
    <IModuleContainer>(this).
    // Add environment variables
    <IAbpHostEnvironment>(new AbpHostEnvironment())
    {
        EnvironmentName =
    });

    // Add logs, options, etc.
    ();
    // Add the core Abp service, and the module's four application lifecycles
    (this, options); //add the core Abp service, and the module's four application lifecycles

   // Read all the modules and execute their lifecycle methods in the order of preloading, initialization, and initialization completion
    Modules = LoadModules(services, options); //Read all the modules and execute their life cycle methods in the order of preloading and initialization completion.

    // Default to true, do not execute
    if (!)
    {
        ConfigureServices(); }
    }
}

Adding core ABP services

AddCoreServices() The method is to add include regular logging, options, localization.
AddCoreAbpServices() The way to do this is to add Abp's core services, including the various readers, configure the

    /// <summary>
    /// Add core services
    /// </summary>
    /// <param name="services"></param>
    internal static void AddCoreServices(this IServiceCollection services)
    {
        //Add Options
        ();
        //Add Log
        ();
        //Add Localization
        ();
    }

    /// <summary>
    /// Add CoreABPservice
    /// </summary>
    /// <param name="services"></param>
    /// <param name="abpApplication"></param>
    /// <param name="applicationCreationOptions"></param>
    internal static void AddCoreAbpServices(this IServiceCollection services,
        IAbpApplication abpApplication,
        AbpApplicationCreationOptions applicationCreationOptions)
    {
        var moduleLoader = new ModuleLoader();
        var assemblyFinder = new AssemblyFinder(abpApplication);
        var typeFinder = new TypeFinder(assemblyFinder);

        if (!<IConfiguration>())
        {
            (
                (
                    
                )
            );
        }

        //Add various readers and finders
        <IModuleLoader>(moduleLoader);
        <IAssemblyFinder>(assemblyFinder);
        <ITypeFinder>(typeFinder);
        <IInitLoggerFactory>(new DefaultInitLoggerFactory());

        //increase AbpApplicationType of program set in which it is located
        <IAbpApplication>();

        (typeof(ISimpleStateCheckerManager<>), typeof(SimpleStateCheckerManager<>));

        //Configuring Lifecycle Options
        <AbpModuleLifecycleOptions>(options =>
        {
            <OnPreApplicationInitializationModuleLifecycleContributor>();
            <OnApplicationInitializationModuleLifecycleContributor>();
            <OnPostApplicationInitializationModuleLifecycleContributor>();
            <OnApplicationShutdownModuleLifecycleContributor>();
        });
    }

retrieval module

go intoIModuleLoader The default implementation of theModuleLoaderIn itsLoadModules() method, the basic logic is as follows:

Scans all module classes of the current application and builds a module description object.
Based on the module description object, a topological sorting algorithm is used to sort the modules according to their dependencies.
After sorting is complete, iterates through the sorted module description objects and executes their three lifecycle methods in turn.

    protected virtual IReadOnlyList<IAbpModuleDescriptor> LoadModules(IServiceCollection services, AbpApplicationCreationOptions options)
    {
        //pass (a bill or inspection etc)ModelLoaderInstance Reading Module，LoadModulesinstance is added to the container when the
        return services
            .GetSingletonInstance<IModuleLoader>()
            .LoadModules(
                services,
                StartupModuleType,
                
            );
    }

        /// <summary>
    /// retrieval module
    /// </summary>
    /// <param name="services"></param>
    /// <param name="startupModuleType"></param>
    /// <param name="plugInSources"></param>
    /// <returns></returns>
    public IAbpModuleDescriptor[] LoadModules(
        IServiceCollection services,
        Type startupModuleType,
        PlugInSourceList plugInSources)
    {
        (services, nameof(services));
        (startupModuleType, nameof(startupModuleType));
        (plugInSources, nameof(plugInSources));
        //Get module description
        var modules = GetDescriptors(services, startupModuleType, plugInSources);
        //arrange in order
        modules = SortByDependency(modules, startupModuleType);

        return ();
    }
        /// <summary>
    /// Get module description
    /// </summary>
    /// <param name="services"></param>
    /// <param name="startupModuleType"></param>
    /// <param name="plugInSources"></param>
    /// <returns></returns>
    private List<IAbpModuleDescriptor> GetDescriptors(
        IServiceCollection services,
        Type startupModuleType,
        PlugInSourceList plugInSources)
    {
        var modules = new List<AbpModuleDescriptor>();

        //findModule
        FillModules(modules, services, startupModuleType, plugInSources);
        //Add to the current module description object's Dependencies causality
        SetDependencies(modules);

        return <IAbpModuleDescriptor>().ToList();
    }

        /// <summary>
    /// find所有的模块
    /// </summary>
    /// <param name="modules"></param>
    /// <param name="services"></param>
    /// <param name="startupModuleType"></param>
    /// <param name="plugInSources"></param>
    protected virtual void FillModules(
        List<AbpModuleDescriptor> modules,
        IServiceCollection services,
        Type startupModuleType,
        PlugInSourceList plugInSources)
    {
        var logger = <AbpApplicationBase>();

         //find到所有的模块
        //All modules starting from the startup module
        foreach (var moduleType in (startupModuleType, logger))
        {
            //Create a module description and add it to the container
            (CreateModuleDescriptor(services, moduleType));
        }

        //Plugin modules
        foreach (var moduleType in (logger))
        {
            if ((m => == moduleType))
            {
                continue;
            }

            (CreateModuleDescriptor(services, moduleType, isLoadedAsPlugIn: true));
        }
    }

Configuring services (injecting contexts, executing their lifecycle methods)

After the Abp application is created, it calls theConfigureServicesAsync() Methods ,
will be executed in each module:ConfigureServices()、PreConfigureServices()、PostConfigureServices() methodologies

    /// <summary>
    /// Configuration Services
    /// </summary>
    /// <returns></returns>
    /// <exception cref="AbpInitializationException"></exception>
    public virtual async Task ConfigureServicesAsync()
    {
        CheckMultipleConfigureServices();

        //Adding a Service Configuration Context Object to a Container
        var context = new ServiceConfigurationContext(Services);
        (context);

        //Iterate through all the modules in the container，and specify the context object
        foreach (var module in Modules)
        {
            if ( is AbpModule abpModule)
            {
                 = context;
            }
        }

        //Traversing the execution module in thePreConfigureServicesAsyncmethodologies（ConfigureServicesbefore executing）
        foreach (var module in (m => is IPreConfigureServices))
        {
            try
            {
                await ((IPreConfigureServices)).PreConfigureServicesAsync(context);
            }
            catch (Exception ex)
            {
                throw new AbpInitializationException($"An error occurred during {nameof()} phase of the module {}. See the inner exception for details.", ex);
            }
        }

        var assemblies = new HashSet<Assembly>();

        ////ergodic module，Inject all the modules that need to be injected.
        foreach (var module in Modules)
        {
            if ( is AbpModule abpModule)
            {
                if (!)
                {
                    foreach (var assembly in )
                    {
                        if (!(assembly))
                        {
                            (assembly);
                            (assembly);
                        }
                    }
                }
            }

            try
            {
                //执行模块实例中的methodologies
                await (context);
            }
            catch (Exception ex)
            {
                throw new AbpInitializationException($"An error occurred during {nameof()} phase of the module {}. See the inner exception for details.", ex);
            }
        }

        //Traversing the execution module in thePostConfigureServicesAsyncmethodologies（ConfigureServicesAfter that, execute the）
        foreach (var module in (m => is IPostConfigureServices))
        {
            try
            {
                await ((IPostConfigureServices)).PostConfigureServicesAsync(context);
            }
            catch (Exception ex)
            {
                throw new AbpInitializationException($"An error occurred during {nameof()} phase of the module {}. See the inner exception for details.", ex);
            }
        }

        //Iterate through all the modules in the container，and empties the context object
        foreach (var module in Modules)
        {
            if ( is AbpModule abpModule)
            {
                 = null!;
            }
        }

        _configuredServices = true;

        TryToSetEnvironment(Services);
    }

Component auto-registration source code analysis

ABP provides three interfaces:ISingletonDependency cap (a poem)ITransientDependency 、IScopedDependency interfaces are injected in the same way as the
To facilitate the auto-registration of our types/components, these three interfaces correspond to the single instance, transient, and scoped lifecycles of an object, respectively.
As long as any type/interface implements any of the above interfaces, ABP vNext registers these objects with the IoC container at system startup
It can also be accessed through theDependencyAttribute Features De-tags the type of service and specifies the service lifecycle.
The module system calls the module'sConfigureServicesAsync() The time comes when there is a()Methods.
He'll pass in the assembly the module belongs to.

        //ConfigureServices
        foreach (var module in Modules)
        {
            if ( is AbpModule abpModule)
            {
                //Whether to skip the automatic registration of services，default false
                if (!)
                {
                    foreach (var assembly in )
                    {
                        if (!(assembly))
                        {
                            //Injecting the current assembly
                            (assembly);
                            (assembly);
                        }
                    }
                }
            }

            try
            {
                (context);
            }
            catch (Exception ex)
            {
                throw new AbpInitializationException($"An error occurred during {nameof()} phase of the module {}. See the inner exception for details.", ex);
            }
        }

Registration is done by obtaining a rule registrar, the default one that comes with the Abp framework.DefaultConventionalRegistrar You can also customize the register
By realizingConventionalRegistrarBase Abstract class de-customization

    public static IServiceCollection AddAssembly(this IServiceCollection services, Assembly assembly)
    {
        ///Get all registers，Then call the register's AddAssembly Method Registration Type。
        foreach (var registrar in ())
        {
            (services, assembly);
        }

        return services;
    }

//abstract base class
    public abstract class ConventionalRegistrarBase : IConventionalRegistrar
{
    /// <summary>
    ///
    /// </summary>
    /// <param name="services"></param>
    /// <param name="assembly"></param>
    public virtual void AddAssembly(IServiceCollection services, Assembly assembly)
    {
        //Get all types in the assembly，Filtering out abstract classes and generic types。
        var types = AssemblyHelper
            .GetAllTypes(assembly)
            .Where(
                type => type != null &&
                         &&
                        ! &&
                        !
            ).ToArray();

        AddTypes(services, types);
    }

    //Add Type
    public virtual void AddTypes(IServiceCollection services, params Type[] types)
    {
        foreach (var type in types)
        {
            AddType(services, type);
        }
    }

    public abstract void AddType(IServiceCollection services, Type type);
}

• The default registrar through which you can register

public class DefaultConventionalRegistrar : ConventionalRegistrarBase
{
    /// <summary>
    /// Add Type
    /// </summary>
    /// <param name="services"></param>
    /// <param name="type"></param>
    public override void AddType(IServiceCollection services, Type type)
    {
        //If you mark the：DisableConventionalRegistrationAttributespecific，No injection
        if (IsConventionalRegistrationDisabled(type))
        {
            return;
        }

        //gainDependencydependency property
        var dependencyAttribute = GetDependencyAttributeOrNull(type);

        //gain生命周期
        var lifeTime = GetLifeTimeOrNull(type, dependencyAttribute);

        if (lifeTime == null)
        {
            return;
        }

        //Conversion to service mark
        var exposedServiceAndKeyedServiceTypes = GetExposedKeyedServiceTypes(type).Concat(GetExposedServiceTypes(type).Select(t => new ServiceIdentifier(t))).ToList();

        //Generation Services
        TriggerServiceExposing(services, type, exposedServiceAndKeyedServiceTypes);

        foreach (var exposedServiceType in exposedServiceAndKeyedServiceTypes)
        {
            var allExposingServiceTypes = == null
                ? (x => == null).ToList()
                : (x => ?.ToString() == ?.ToString()).ToList();

            //Creating a Service Description
            var serviceDescriptor = CreateServiceDescriptor(
                type,
                ,
                ,
                allExposingServiceTypes,
                
            );

            if (dependencyAttribute?.ReplaceServices == true)
            {
                (serviceDescriptor);
            }
            else if (dependencyAttribute?.TryRegister == true)
            {
                (serviceDescriptor);
            }
            else
            {
                (serviceDescriptor);
            }
        }
    }
}

• through (a gap)GetLifeTimeOrNull method to get the life cycle

    /// <summary>
    /// Getting the life cycle
    /// </summary>
    /// <param name="type"></param>
    /// <param name="dependencyAttribute"></param>
    /// <returns></returns>
    protected virtual ServiceLifetime? GetLifeTimeOrNull(Type type, DependencyAttribute? dependencyAttribute)
    {
        // Lifecycle is set in the feature or the interface is inherited.
        return dependencyAttribute?.Lifetime ?? GetServiceLifetimeFromClassHierarchy(type) ?? GetDefaultLifeTimeOrNull(type);
    }

    /// <summary>
    /// 从接口中Getting the life cycle
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    protected virtual ServiceLifetime? GetServiceLifetimeFromClassHierarchy(Type type)
    {
        if (typeof(ITransientDependency).GetTypeInfo().IsAssignableFrom(type))
        {
            return ;
        }

        if (typeof(ISingletonDependency).GetTypeInfo().IsAssignableFrom(type))
        {
            return ;
        }

        if (typeof(IScopedDependency).GetTypeInfo().IsAssignableFrom(type))
        {
            return ;
        }

        return null;
    }

Initializing the ABP Application

• pass (a bill or inspection etc)await (); method will initialize the application and then execute the methods of the lifecycle in each module

    /// <summary>
    /// Asynchronous initialization of ABP applications
    /// </summary> /// Asynchronous initialization of ABP applications
    /// <param name="app"></param> /// <returns>< /param>
    /// <returns></returns> /// <param name="app"></param>
    public async static Task InitializeApplicationAsync([NotNull] this IApplicationBuilder app)
    {
        (app, nameof(app));

        <ObjectAccessor<IApplicationBuilder>>().Value = app;
        var application = <IAbpApplicationWithExternalServiceProvider>();
        var applicationLifetime = <IHostApplicationLifetime>();

        //Register the application lifecycle stop event
        (() =>
        {
            //Execute the ShutdownAsync method in the Abp program, which calls the ShutdownAsync method in each module.
            (() => ()); {/Execute the ShutdownAsync method in the Abp program.
        }).

        // Release the Abp application
        (() => ()); })
        {
            ();
        }).

        // Execute the InitializeAbp method, initializing each module and executing the InitializeAsync method in each module.
        await (); }
    }

• Initialize each module life cycle method

   /// <summary>
   /// Setting up the service provider
   /// </summary>
   /// <param name="serviceProvider"></param>
    protected virtual void SetServiceProvider(IServiceProvider serviceProvider)
    {
        ServiceProvider = serviceProvider;
        <ObjectAccessor<IServiceProvider>>().Value = ServiceProvider;
    }

    /// <summary>
    /// Initialization Module
    /// </summary>
    /// <returns></returns>
    protected virtual async Task InitializeModulesAsync()
    {
        using (var scope = ())
        {
            WriteInitLogs();
            await
                .GetRequiredService<IModuleManager>() //Initialization Module
                .InitializeModulesAsync(new ApplicationInitializationContext());
        }
    }

    /// <summary>
    /// Initialization Module
    /// </summary>
    /// <param name="context"></param>
    /// <returns></returns>
    /// <exception cref="AbpInitializationException"></exception>
    public virtual async Task InitializeModulesAsync(ApplicationInitializationContext context)
    {
        // former AddCoreAbpServices() methodologies configured life cycle，
        foreach (var contributor in _lifecycleContributors)
        {
            foreach (var module in _moduleContainer.Modules)
            {
                try
                {
                    //执行每个life cycle(Before loading、loading、After loading)hit the nail on the head initialization method
                    await (context, );
                }
                catch (Exception ex)
                {
                    throw new AbpInitializationException($"An error occurred during the initialize {().FullName} phase of the module {}: {}. See the inner exception for details.", ex);
                }
            }
        }

        _logger.LogInformation("Initialized all ABP modules.");
    }

• Four life cyclesOnApplicationInitializationModuleLifecycleContributor 、
  OnPreApplicationInitializationModuleLifecycleContributor 、
  OnPostApplicationInitializationModuleLifecycleContributor
OnApplicationShutdownModuleLifecycleContributor methods in the module, which are actually calls to the lifecycle methods in the specific module.

public class OnApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
{
    public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
    {
        if (module is IOnApplicationInitialization onApplicationInitialization)
        {
            await (context);
        }
    }

    public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
    {
        (module as IOnApplicationInitialization)?.OnApplicationInitialization(context);
    }
}

public class OnApplicationShutdownModuleLifecycleContributor : ModuleLifecycleContributorBase
{
    public async override Task ShutdownAsync(ApplicationShutdownContext context, IAbpModule module)
    {
        if (module is IOnApplicationShutdown onApplicationShutdown)
        {
            await (context);
        }
    }

    public override void Shutdown(ApplicationShutdownContext context, IAbpModule module)
    {
        (module as IOnApplicationShutdown)?.OnApplicationShutdown(context);
    }
}

public class OnPreApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
{
    public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
    {
        if (module is IOnPreApplicationInitialization onPreApplicationInitialization)
        {
            await (context);
        }
    }

    public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
    {
        (module as IOnPreApplicationInitialization)?.OnPreApplicationInitialization(context);
    }
}

public class OnPostApplicationInitializationModuleLifecycleContributor : ModuleLifecycleContributorBase
{
    public async override Task InitializeAsync(ApplicationInitializationContext context, IAbpModule module)
    {
        if (module is IOnPostApplicationInitialization onPostApplicationInitialization)
        {
            await (context);
        }
    }

    public override void Initialize(ApplicationInitializationContext context, IAbpModule module)
    {
        (module as IOnPostApplicationInitialization)?.OnPostApplicationInitialization(context);
    }
}