// ServiceCollectionExtensions.cs（Silky.Core）
public static IEngine AddSilkyServices<T>(
    this IServiceCollection services,
    IConfiguration configuration,
    IHostEnvironment hostEnvironment,
    SilkyApplicationCreationOptions options)   // 应用创建选项（插件源、应用名称等）
    where T : SilkyModule                      // 约束：T 必须是 SilkyModule 的子类
{
    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
    CommonSilkyHelpers.DefaultFileProvider = new SilkyFileProvider(hostEnvironment); // 构建文件服务提供者
    services.TryAddSingleton(CommonSilkyHelpers.DefaultFileProvider);
    services.TryAddSingleton<IInitLoggerFactory>(new DefaultInitLoggerFactory());
    services.TryAddTransient<IBannerPrinter, BannerPrinter>();
    services.AddHostedService<InitSilkyHostedService>(); // 注册后台启动任务（模块初始化 / 关闭）
    services.AddSingleton<ICancellationTokenProvider>(NullCancellationTokenProvider.Instance);

    var moduleLoader = new ModuleLoader();
    services.TryAddSingleton<IModuleLoader>(moduleLoader);
    services.AddOptions<PlugInSourceOptions>()
        .Bind(configuration.GetSection(PlugInSourceOptions.PlugInSource));

    var engine = EngineContext.Create(); // 创建全局单例的服务引擎
    engine.SetConfiguration(configuration);           // 注入配置
    engine.SetApplicationOptions(options);            // 注入应用选项
    engine.Banner = BannerHelper.BuildBanner(options);
    engine.SetHostEnvironment(hostEnvironment);       // 注入主机环境
    engine.SetTypeFinder(services,                   // 构建类型查找器（扫描所有程序集）
        CommonSilkyHelpers.DefaultFileProvider,
        options.AppServicePlugInSources,
        options.ModulePlugInSources);
    engine.LoadModules(services, typeof(T), moduleLoader, options.ModulePlugInSources); // 解析并排序所有模块
    engine.ConfigureServices(services, configuration); // 遍历 IConfigureService + 各模块 ConfigureServices
    return engine;
}

internal static IEngine Create()
{
    return Singleton<IEngine>.Instance ?? (Singleton<IEngine>.Instance = new SilkyEngine()); // 服务引擎在应用的整个生命周期是单例的
}

// SilkyEngine 实现的 ConfigureServices 方法
void IEngine.ConfigureServices(IServiceCollection services, IConfiguration configuration)
{
    // 通过类型查找器查找所有 IConfigureService 实现类，并通过反射创建实例
    var configureServices = _typeFinder.FindClassesOfType<IConfigureService>();
    var instances = configureServices
        .Select(configureService => (IConfigureService)Activator.CreateInstance(configureService));

    foreach (var instance in instances)            // 遍历 IConfigureService 实现，完成服务注册
        instance.ConfigureServices(services, Configuration);

    foreach (var module in Modules)                // 遍历所有模块，通过各模块的 ConfigureServices 注册
        module.Instance.ConfigureServices(services, Configuration);

    ServiceProvider = services.BuildServiceProvider(); // 构建初始服务提供者（用于早期解析）
}

// HostBuilderExtensions.cs（Silky.Core）
public static IHostBuilder RegisterSilkyServices<T>(
    this IHostBuilder builder,
    Action<SilkyApplicationCreationOptions> optionsAction = null)
    where T : SilkyModule   // 注意：约束是 SilkyModule，不是 StartUpModule
{
    // 其他代码略...
    builder
        .UseServiceProviderFactory(new AutofacServiceProviderFactory()) // 替换为 Autofac 容器
        .ConfigureContainer<ContainerBuilder>(containerBuilder =>
        {
            engine.RegisterModules(containerBuilder);      // 通过 Autofac Module 注册模块服务
            engine.RegisterDependencies(containerBuilder); // 通过约定接口（ISingletonDependency 等）注册服务
        });
    // ...
}

public void RegisterModules(ContainerBuilder containerBuilder)
{
    containerBuilder.RegisterInstance(this).As<IModuleContainer>().SingleInstance();
    var assemblyNames = ((AppDomainTypeFinder)_typeFinder).AssemblyNames;
    foreach (var module in Modules)
    {
        if (!assemblyNames.Contains(module.Assembly.FullName))
        {
            ((AppDomainTypeFinder)_typeFinder).AssemblyNames.Add(module.Assembly.FullName);
        }
        // Autofac 内部会调用 module.Load() -> RegisterServices(builder)
        containerBuilder.RegisterModule((SilkyModule)module.Instance);
    }
}

protected override void Load([NotNull] ContainerBuilder builder)
{
    base.Load(builder);
    RegisterServices(builder);
}

protected virtual void RegisterServices([NotNull] ContainerBuilder builder)
{
}

 public void RegisterDependencies(ContainerBuilder containerBuilder)
{
    containerBuilder.RegisterInstance(this).As<IEngine>().SingleInstance();
    containerBuilder.RegisterInstance(_typeFinder).As<ITypeFinder>().SingleInstance();

    var dependencyRegistrars = _typeFinder.FindClassesOfType<IDependencyRegistrar>();
    var instances = dependencyRegistrars
        .Select(dependencyRegistrar => (IDependencyRegistrar)Activator.CreateInstance(dependencyRegistrar))
        .OrderBy(dependencyRegistrar => dependencyRegistrar.Order);
    foreach (var dependencyRegistrar in instances)
        dependencyRegistrar.Register(containerBuilder, _typeFinder);
}

// 该服务将会被注册为范围的,并被命名为:DemoService,在服务解析过程中可以通过服务名 DemoService 解析到
[InjectNamed("DemoService")]
public class DemoService : IScopedDependency
{

}