feat(architecture): 实现服务模块化管理和ECS功能

- 将架构服务重构为模块化设计，引入ServiceModuleManager统一管理
- 新增EventBusModule、CommandExecutorModule、QueryExecutorModule等核心服务模块
- 实现ECS模块支持，可配置启用Entity Component System功能
- 在架构初始化过程中集成模块注册、初始化和销毁流程
- 更新架构属性配置，添加EnableEcs开关控制ECS功能启用
- 优化服务获取方式，从直接依赖改为通过容器动态获取
- 移除架构上下文中的ECS相关实现代码，统一由ECS模块管理

GFramework.Core.Abstractions/architecture/IServiceModule.cs

@@ -0,0 +1,34 @@
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.Abstractions.lifecycle;
+
+namespace GFramework.Core.Abstractions.architecture;
+
+/// <summary>
+///     服务模块接口，定义了服务模块的基本契约。
+///     所有服务模块必须实现此接口，以支持注册、初始化和异步销毁功能。
+/// </summary>
+public interface IServiceModule : IInitializable, IAsyncDestroyable
+{
+    /// <summary>
+    ///     获取模块的唯一名称。
+    /// </summary>
+    string ModuleName { get; }
+
+    /// <summary>
+    ///     获取模块的优先级，数值越小优先级越高。
+    ///     用于控制模块的注册和初始化顺序。
+    /// </summary>
+    int Priority { get; }
+
+    /// <summary>
+    ///     获取模块的启用状态。
+    ///     返回 true 表示模块已启用，false 表示模块被禁用。
+    /// </summary>
+    bool IsEnabled { get; }
+
+    /// <summary>
+    ///     注册模块提供的服务到依赖注入容器中。
+    /// </summary>
+    /// <param name="container">依赖注入容器实例，用于注册服务。</param>
+    void Register(IIocContainer container);
+}

GFramework.Core.Abstractions/architecture/IServiceModuleManager.cs

@@ -0,0 +1,17 @@
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.Abstractions.properties;
+
+namespace GFramework.Core.Abstractions.architecture;
+
+public interface IServiceModuleManager
+{
+    void RegisterModule(IServiceModule module);
+
+    void RegisterBuiltInModules(IIocContainer container, ArchitectureProperties properties);
+
+    IReadOnlyList<IServiceModule> GetModules();
+
+    Task InitializeAllAsync(bool asyncMode);
+
+    ValueTask DestroyAllAsync();
+}

GFramework.Core.Abstractions/properties/ArchitectureProperties.cs

@@ -1,17 +1,26 @@
-namespace GFramework.Core.Abstractions.properties;
+namespace GFramework.Core.Abstractions.properties;
 
 /// <summary>
-///     架构选项配置类，用于定义架构行为的相关配置选项
+///     架构选项配置类，用于定义架构行为的相关配置选项。
+///     通过该类可以控制架构的初始化行为和运行时特性。
 /// </summary>
 public sealed class ArchitectureProperties
 {
     /// <summary>
-    ///     允许延迟注册开关，当设置为true时允许在初始化完成后进行组件注册
+    ///     允许延迟注册开关，当设置为 true 时允许在初始化完成后进行组件注册。
+    ///     默认值为 false，表示不允许延迟注册。
     /// </summary>
     public bool AllowLateRegistration { get; set; }
 
     /// <summary>
-    ///     严格阶段验证开关，当设置为true时启用严格的阶段验证机制
+    ///     严格阶段验证开关，当设置为 true 时启用严格的阶段验证机制。
+    ///     默认值为 false，表示不启用严格验证。
     /// </summary>
     public bool StrictPhaseValidation { get; set; }
+
+    /// <summary>
+    ///     启用 ECS（Entity Component System）功能的开关。
+    ///     当设置为 true 时，架构将启用 ECS 相关功能。
+    /// </summary>
+    public bool EnableEcs { get; set; }
 }

GFramework.Core/architecture/Architecture.cs

@@ -68,10 +68,7 @@ public abstract class Architecture(
     /// </summary>
     private IEnvironment Environment { get; } = environment ?? new DefaultEnvironment();
 
-    /// <summary>
-    ///     获取架构服务对象
-    /// </summary>
-    private IArchitectureServices Services { get; } = services ?? new ArchitectureServices();
+    private ArchitectureServices Services { get; } = services as ArchitectureServices ?? new ArchitectureServices();
 
     /// <summary>
     ///     获取依赖注入容器
@@ -401,6 +398,10 @@ public abstract class Architecture(
 
         _disposables.Clear();
         _disposableSet.Clear();
+
+        // 销毁服务模块
+        await Services.ModuleManager.DestroyAllAsync();
+
         Container.Clear();
 
         // 进入已销毁阶段
@@ -640,6 +641,9 @@ public abstract class Architecture(
         _logger = LoggerFactoryResolver.Provider.CreateLogger(GetType().Name);
         Environment.Initialize();
 
+        // 注册内置服务模块（根据配置）
+        Services.ModuleManager.RegisterBuiltInModules(Container, Configuration.ArchitectureProperties);
+
         // 将 Environment 注册到容器（如果尚未注册）
         if (!Container.Contains<IEnvironment>())
             Container.RegisterPlurality(Environment);
@@ -657,6 +661,10 @@ public abstract class Architecture(
 
         // 执行服务钩子
         Container.ExecuteServicesHook(Configurator);
+
+        // 初始化服务模块
+        await Services.ModuleManager.InitializeAllAsync(asyncMode);
+
         // === 用户 OnInitialize ===
         _logger.Debug("Calling user OnInitialize()");
         OnInitialize();

GFramework.Core/architecture/ArchitectureContext.cs

@@ -1,4 +1,3 @@
-using System.Diagnostics.CodeAnalysis;
 using GFramework.Core.Abstractions.architecture;
 using GFramework.Core.Abstractions.command;
 using GFramework.Core.Abstractions.ecs;
@@ -9,7 +8,6 @@ using GFramework.Core.Abstractions.model;
 using GFramework.Core.Abstractions.query;
 using GFramework.Core.Abstractions.system;
 using GFramework.Core.Abstractions.utility;
-using GFramework.Core.ecs;
 using Mediator;
 using ICommand = GFramework.Core.Abstractions.command.ICommand;
 
@@ -22,10 +20,8 @@ public class ArchitectureContext(IIocContainer container) : IArchitectureContext
 {
     private readonly IIocContainer _container = container ?? throw new ArgumentNullException(nameof(container));
     private readonly Dictionary<Type, object> _serviceCache = new();
-    private EcsSystemRunner? _ecsRunner;
-    private EcsWorld? _ecsWorld;
 
-    #region Mediator Integration (新实现)
+    #region Mediator Integration
 
     /// <summary>
     /// 获取 Mediator 实例（延迟加载）
@@ -424,56 +420,22 @@ public class ArchitectureContext(IIocContainer container) : IArchitectureContext
     ///     获取ECS世界实例
     /// </summary>
     /// <returns>ECS世界实例</returns>
-    [Experimental("GFrameworkECS")]
     public IEcsWorld GetEcsWorld()
     {
-        return _ecsWorld ??
-               throw new InvalidOperationException("ECS World not initialized. Call InitializeEcs() first.");
+        var ecsWorld = GetOrCache<IEcsWorld>();
+        return ecsWorld ??
+               throw new InvalidOperationException("ECS World not initialized. Enable ECS in configuration.");
     }
 
     /// <summary>
     ///     注册ECS系统
     /// </summary>
     /// <typeparam name="T">ECS系统类型</typeparam>
-    [Experimental("GFrameworkECS")]
     public void RegisterEcsSystem<T>() where T : class, IEcsSystem
     {
         // 使用RegisterPlurality注册到所有接口
         _container.RegisterPlurality<T>();
     }
 
-    /// <summary>
-    ///     初始化ECS（在架构初始化时调用）
-    /// </summary>
-    [Experimental("GFrameworkECS")]
-    public void InitializeEcs()
-    {
-        if (_ecsWorld != null) return;
-
-        // 创建ECS世界
-        _ecsWorld = new EcsWorld();
-        _container.Register(_ecsWorld);
-
-        // 注册系统调度器
-        _container.RegisterPlurality<EcsSystemRunner>();
-        _ecsRunner = _container.Get<EcsSystemRunner>();
-    }
-
-    /// <summary>
-    ///     获取ECS系统调度器
-    /// </summary>
-    internal EcsSystemRunner? GetEcsRunner() => _ecsRunner;
-
-    /// <summary>
-    ///     销毁ECS资源
-    /// </summary>
-    [Experimental("GFrameworkECS")]
-    private void DisposeEcs()
-    {
-        _ecsWorld?.Dispose();
-        _ecsWorld = null;
-        _ecsRunner = null;
-    }
-
     #endregion
 }

GFramework.Core/architecture/ArchitectureServices.cs

@@ -3,94 +3,71 @@ using GFramework.Core.Abstractions.command;
 using GFramework.Core.Abstractions.events;
 using GFramework.Core.Abstractions.ioc;
 using GFramework.Core.Abstractions.query;
-using GFramework.Core.command;
-using GFramework.Core.events;
 using GFramework.Core.ioc;
-using GFramework.Core.query;
+using GFramework.Core.services;
 
 namespace GFramework.Core.architecture;
 
 /// <summary>
-///     架构服务类，提供依赖注入容器、事件系统、命令总线和查询总线等核心服务
+///     架构服务类，提供依赖注入容器、事件系统、命令总线和查询总线等核心服务。
+///     该类负责管理架构运行所需的核心组件，并提供统一的服务访问接口。
 /// </summary>
 public class ArchitectureServices : IArchitectureServices
 {
-    /// <summary>
-    ///     异步查询执行器实例
-    /// </summary>
-    private readonly IAsyncQueryExecutor _asyncQueryExecutor;
-
-    /// <summary>
-    ///     命令执行器实例
-    /// </summary>
-    private readonly ICommandExecutor _commandExecutor;
-
-    /// <summary>
-    ///     事件总线实例
-    /// </summary>
-    private readonly IEventBus _eventBus;
-
-    /// <summary>
-    ///     同步查询执行器实例
-    /// </summary>
-    private readonly IQueryExecutor _queryExecutor;
-
-    /// <summary>
-    ///     架构上下文对象
-    /// </summary>
+    private readonly IServiceModuleManager _moduleManager;
     private IArchitectureContext _context = null!;
 
     /// <summary>
-    ///     构造函数，初始化架构服务
+    ///     构造函数，初始化架构服务。
     ///     初始化依赖注入容器，并创建事件总线、命令执行器、查询执行器和异步查询执行器的实例，
     ///     然后将这些服务注册到容器中。
     /// </summary>
     public ArchitectureServices()
     {
         Container = new MicrosoftDiContainer();
-
-        // 创建服务实例
-        _eventBus = new EventBus();
-        _commandExecutor = new CommandExecutor();
-        _queryExecutor = new QueryExecutor();
-        _asyncQueryExecutor = new AsyncQueryExecutor();
-
-        // 将服务注册到容器
-        Container.RegisterPlurality(_eventBus);
-        Container.RegisterPlurality(_commandExecutor);
-        Container.RegisterPlurality(_queryExecutor);
-        Container.RegisterPlurality(_asyncQueryExecutor);
+        _moduleManager = new ServiceModuleManager();
     }
 
     /// <summary>
-    ///     获取依赖注入容器
+    ///     获取服务模块管理器实例。
+    ///     服务模块管理器用于管理架构中的服务模块，支持模块的动态加载和卸载。
+    /// </summary>
+    public IServiceModuleManager ModuleManager => _moduleManager;
+
+    /// <summary>
+    ///     获取依赖注入容器。
+    ///     该容器用于管理架构中所有服务的生命周期和依赖关系。
     /// </summary>
     public IIocContainer Container { get; }
 
     /// <summary>
-    ///     获取事件总线实例
+    ///     获取事件总线实例。
+    ///     事件总线用于在架构中发布和订阅事件，实现组件间的松耦合通信。
     /// </summary>
-    public IEventBus EventBus => _eventBus;
+    public IEventBus EventBus => Container.Get<IEventBus>()!;
 
     /// <summary>
-    ///     获取命令执行器实例
+    ///     获取命令执行器实例。
+    ///     命令执行器用于处理命令请求，执行业务逻辑。
     /// </summary>
-    public ICommandExecutor CommandExecutor => _commandExecutor;
+    public ICommandExecutor CommandExecutor => Container.Get<ICommandExecutor>()!;
 
     /// <summary>
-    ///     获取同步查询执行器实例
+    ///     获取查询执行器实例。
+    ///     查询执行器用于处理同步查询请求，获取数据或状态信息。
     /// </summary>
-    public IQueryExecutor QueryExecutor => _queryExecutor;
+    public IQueryExecutor QueryExecutor => Container.Get<IQueryExecutor>()!;
 
     /// <summary>
-    ///     获取异步查询执行器实例
+    ///     获取异步查询执行器实例。
+    ///     异步查询执行器用于处理异步查询请求，支持非阻塞的数据获取操作。
     /// </summary>
-    public IAsyncQueryExecutor AsyncQueryExecutor => _asyncQueryExecutor;
+    public IAsyncQueryExecutor AsyncQueryExecutor => Container.Get<IAsyncQueryExecutor>()!;
 
     /// <summary>
-    ///     设置架构上下文
+    ///     设置架构上下文。
     /// </summary>
-    /// <param name="context">架构上下文对象</param>
+    /// <param name="context">要设置的架构上下文实例。</param>
     public void SetContext(IArchitectureContext context)
     {
         _context = context;
@@ -98,9 +75,9 @@ public class ArchitectureServices : IArchitectureServices
     }
 
     /// <summary>
-    ///     获取架构上下文
+    ///     获取当前架构上下文。
     /// </summary>
-    /// <returns>架构上下文对象</returns>
+    /// <returns>当前的架构上下文实例。</returns>
     public IArchitectureContext GetContext()
     {
         return _context;

GFramework.Core/services/ServiceModuleManager.cs

@@ -0,0 +1,139 @@
+using GFramework.Core.Abstractions.architecture;
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.Abstractions.lifecycle;
+using GFramework.Core.Abstractions.logging;
+using GFramework.Core.Abstractions.properties;
+using GFramework.Core.logging;
+using GFramework.Core.services.modules;
+
+namespace GFramework.Core.services;
+
+/// <summary>
+///     服务模块管理器，负责注册、初始化和销毁架构中的服务模块。
+///     支持模块的优先级排序、异步初始化和异常安全的销毁流程。
+/// </summary>
+public sealed class ServiceModuleManager : IServiceModuleManager
+{
+    private readonly ILogger _logger = LoggerFactoryResolver.Provider.CreateLogger(nameof(ServiceModuleManager));
+    private readonly List<IServiceModule> _modules = [];
+
+    /// <summary>
+    ///     注册单个服务模块。
+    ///     如果模块为空或已存在同名模块，则记录警告日志并跳过注册。
+    /// </summary>
+    /// <param name="module">要注册的服务模块实例。</param>
+    public void RegisterModule(IServiceModule? module)
+    {
+        if (module == null)
+        {
+            _logger.Warn("Attempted to register null module");
+            return;
+        }
+
+        if (_modules.Any(m => m.ModuleName == module.ModuleName))
+        {
+            _logger.Warn($"Module {module.ModuleName} already registered");
+            return;
+        }
+
+        _modules.Add(module);
+        _logger.Debug($"Module registered: {module.ModuleName} (Priority: {module.Priority})");
+    }
+
+    /// <summary>
+    ///     注册内置服务模块。
+    ///     根据配置属性决定是否启用特定模块（如ECS模块），并对模块按优先级排序后注册到容器中。
+    /// </summary>
+    /// <param name="container">依赖注入容器，用于注册模块提供的服务。</param>
+    /// <param name="properties">架构配置属性，用于控制模块的启用状态。</param>
+    public void RegisterBuiltInModules(IIocContainer container, ArchitectureProperties properties)
+    {
+        RegisterModule(new EventBusModule());
+        RegisterModule(new CommandExecutorModule());
+        RegisterModule(new QueryExecutorModule());
+        RegisterModule(new AsyncQueryExecutorModule());
+
+        if (properties.EnableEcs)
+        {
+            RegisterModule(new EcsModule(enabled: true));
+            _logger.Info("ECS module enabled via configuration");
+        }
+
+        var sortedModules = _modules.OrderBy(m => m.Priority).ToList();
+        _modules.Clear();
+        _modules.AddRange(sortedModules);
+
+        foreach (var module in _modules.Where(module => module.IsEnabled))
+        {
+            _logger.Debug($"Registering services for module: {module.ModuleName}");
+            module.Register(container);
+        }
+
+        _logger.Info($"Registered {_modules.Count} built-in service modules");
+    }
+
+    /// <summary>
+    ///     获取所有已注册的服务模块列表。
+    /// </summary>
+    /// <returns>只读的服务模块列表。</returns>
+    public IReadOnlyList<IServiceModule> GetModules()
+    {
+        return _modules.AsReadOnly();
+    }
+
+    /// <summary>
+    ///     异步初始化所有启用的服务模块。
+    ///     支持同步和异步初始化模式，优先使用异步接口（如果模块实现了IAsyncInitializable）。
+    /// </summary>
+    /// <param name="asyncMode">是否启用异步初始化模式。</param>
+    /// <returns>表示异步操作的任务。</returns>
+    public async Task InitializeAllAsync(bool asyncMode)
+    {
+        _logger.Info($"Initializing {_modules.Count} service modules");
+
+        foreach (var module in _modules.Where(m => m.IsEnabled))
+        {
+            _logger.Debug($"Initializing module: {module.ModuleName}");
+
+            if (asyncMode && module is IAsyncInitializable asyncInitializable)
+            {
+                await asyncInitializable.InitializeAsync();
+            }
+            else
+            {
+                module.Initialize();
+            }
+        }
+
+        _logger.Info("All service modules initialized");
+    }
+
+    /// <summary>
+    ///     异步销毁所有启用的服务模块。
+    ///     按逆序销毁模块以确保依赖关系正确释放，并捕获异常避免中断整个销毁流程。
+    /// </summary>
+    /// <returns>表示异步操作的值任务。</returns>
+    public async ValueTask DestroyAllAsync()
+    {
+        _logger.Info($"Destroying {_modules.Count} service modules");
+
+        for (var i = _modules.Count - 1; i >= 0; i--)
+        {
+            var module = _modules[i];
+            if (!module.IsEnabled) continue;
+
+            try
+            {
+                _logger.Debug($"Destroying module: {module.ModuleName}");
+                await module.DestroyAsync();
+            }
+            catch (Exception ex)
+            {
+                _logger.Error($"Error destroying module {module.ModuleName}", ex);
+            }
+        }
+
+        _modules.Clear();
+        _logger.Info("All service modules destroyed");
+    }
+}

GFramework.Core/services/modules/AsyncQueryExecutorModule.cs

@@ -0,0 +1,55 @@
+using GFramework.Core.Abstractions.architecture;
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.query;
+
+namespace GFramework.Core.services.modules;
+
+/// <summary>
+///     异步查询执行器模块，用于注册和管理异步查询执行器服务。
+///     该模块负责将异步查询执行器注册到依赖注入容器中，并在销毁时释放相关资源。
+/// </summary>
+public sealed class AsyncQueryExecutorModule : IServiceModule
+{
+    /// <summary>
+    ///     获取模块名称。
+    /// </summary>
+    public string ModuleName => nameof(AsyncQueryExecutorModule);
+
+    /// <summary>
+    ///     获取模块优先级，数值越小优先级越高。
+    /// </summary>
+    public int Priority => 40;
+
+    /// <summary>
+    ///     获取模块启用状态，始终返回 true 表示该模块默认启用。
+    /// </summary>
+    public bool IsEnabled => true;
+
+    /// <summary>
+    ///     注册异步查询执行器到依赖注入容器。
+    ///     创建异步查询执行器实例并将其注册为多例服务。
+    /// </summary>
+    /// <param name="container">依赖注入容器实例。</param>
+    public void Register(IIocContainer container)
+    {
+        container.RegisterPlurality(new AsyncQueryExecutor());
+    }
+
+    /// <summary>
+    ///     初始化模块。
+    ///     当前实现为空，因为异步查询执行器无需额外初始化逻辑。
+    /// </summary>
+    public void Initialize()
+    {
+    }
+
+    /// <summary>
+    ///     异步销毁模块并释放资源。
+    ///     将异步查询执行器引用置空以允许垃圾回收。
+    /// </summary>
+    /// <returns>表示异步操作完成的任务。</returns>
+    public ValueTask DestroyAsync()
+    {
+        return ValueTask.CompletedTask;
+    }
+}

GFramework.Core/services/modules/CommandExecutorModule.cs

@@ -0,0 +1,55 @@
+using GFramework.Core.Abstractions.architecture;
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.command;
+
+namespace GFramework.Core.services.modules;
+
+/// <summary>
+///     命令执行器模块，用于注册和管理命令执行器服务。
+///     该模块负责将命令执行器注册到依赖注入容器中，并在销毁时释放相关资源。
+/// </summary>
+public sealed class CommandExecutorModule : IServiceModule
+{
+    /// <summary>
+    ///     获取模块名称。
+    /// </summary>
+    public string ModuleName => nameof(CommandExecutorModule);
+
+    /// <summary>
+    ///     获取模块优先级，数值越小优先级越高。
+    /// </summary>
+    public int Priority => 20;
+
+    /// <summary>
+    ///     获取模块启用状态，始终返回 true 表示该模块默认启用。
+    /// </summary>
+    public bool IsEnabled => true;
+
+    /// <summary>
+    ///     注册命令执行器到依赖注入容器。
+    ///     创建命令执行器实例并将其注册为多例服务。
+    /// </summary>
+    /// <param name="container">依赖注入容器实例。</param>
+    public void Register(IIocContainer container)
+    {
+        container.RegisterPlurality(new CommandExecutor());
+    }
+
+    /// <summary>
+    ///     初始化模块。
+    ///     当前实现为空，因为命令执行器无需额外初始化逻辑。
+    /// </summary>
+    public void Initialize()
+    {
+    }
+
+    /// <summary>
+    ///     异步销毁模块并释放资源。
+    ///     将命令执行器引用置空以允许垃圾回收。
+    /// </summary>
+    /// <returns>表示异步操作完成的任务。</returns>
+    public ValueTask DestroyAsync()
+    {
+        return ValueTask.CompletedTask;
+    }
+}

GFramework.Core/services/modules/EcsModule.cs

@@ -0,0 +1,110 @@
+using GFramework.Core.Abstractions.architecture;
+using GFramework.Core.Abstractions.ecs;
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.Abstractions.lifecycle;
+using GFramework.Core.ecs;
+
+namespace GFramework.Core.services.modules;
+
+/// <summary>
+///     ECS（Entity Component System）模块，用于注册、初始化和管理ECS相关服务。
+///     该模块负责创建ECS世界和系统运行器，并将其注册到依赖注入容器中。
+/// </summary>
+public sealed class EcsModule : IServiceModule
+{
+    private EcsSystemRunner? _ecsRunner;
+
+    private EcsWorld? _ecsWorld;
+
+    /// <summary>
+    ///     构造函数，初始化ECS模块。
+    /// </summary>
+    /// <param name="enabled">指定模块是否启用，默认为 true。</param>
+    public EcsModule(bool enabled = true)
+    {
+        IsEnabled = enabled;
+    }
+
+    /// <summary>
+    ///     获取模块名称。
+    /// </summary>
+    public string ModuleName => nameof(EcsModule);
+
+    /// <summary>
+    ///     获取模块优先级，数值越小优先级越高。
+    /// </summary>
+    public int Priority => 100;
+
+    /// <summary>
+    ///     获取模块启用状态。
+    /// </summary>
+    public bool IsEnabled { get; }
+
+    /// <summary>
+    ///     注册ECS相关服务到依赖注入容器中。
+    ///     包括ECS世界实例和系统运行器实例的注册。
+    /// </summary>
+    /// <param name="container">依赖注入容器实例。</param>
+    public void Register(IIocContainer container)
+    {
+        if (!IsEnabled) return;
+
+        _ecsWorld = new EcsWorld();
+        container.Register(_ecsWorld);
+        container.Register<IEcsWorld>(_ecsWorld);
+
+        container.RegisterPlurality<EcsSystemRunner>();
+        _ecsRunner = container.Get<EcsSystemRunner>();
+    }
+
+    /// <summary>
+    ///     初始化ECS模块。
+    ///     如果系统运行器实现了IInitializable接口，则调用其初始化方法。
+    /// </summary>
+    public void Initialize()
+    {
+        if (!IsEnabled || _ecsRunner == null) return;
+
+        if (_ecsRunner is IInitializable initializable)
+        {
+            initializable.Initialize();
+        }
+    }
+
+    /// <summary>
+    ///     异步销毁ECS模块并释放相关资源。
+    ///     包括销毁系统运行器和释放ECS世界资源。
+    /// </summary>
+    /// <returns>表示异步操作完成的任务。</returns>
+    public async ValueTask DestroyAsync()
+    {
+        if (!IsEnabled) return;
+
+        if (_ecsRunner is IDestroyable destroyable)
+        {
+            destroyable.Destroy();
+        }
+
+        _ecsRunner = null;
+
+        if (_ecsWorld != null)
+        {
+            _ecsWorld.Dispose();
+            _ecsWorld = null;
+        }
+
+        await ValueTask.CompletedTask;
+    }
+
+    /// <summary>
+    ///     获取ECS世界实例。
+    /// </summary>
+    /// <returns>ECS世界实例，如果未启用则返回 null。</returns>
+    public IEcsWorld? GetEcsWorld() => _ecsWorld;
+
+    /// <summary>
+    ///     获取ECS系统运行器实例（内部使用）。
+    /// </summary>
+    /// <returns>ECS系统运行器实例，如果未启用则返回 null。</returns>
+    internal EcsSystemRunner? GetEcsRunner() => _ecsRunner;
+}

GFramework.Core/services/modules/EventBusModule.cs

@@ -0,0 +1,55 @@
+using GFramework.Core.Abstractions.architecture;
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.events;
+
+namespace GFramework.Core.services.modules;
+
+/// <summary>
+///     事件总线模块，用于注册和管理事件总线服务。
+///     该模块负责将事件总线注册到依赖注入容器中，并提供初始化和销毁功能。
+/// </summary>
+public sealed class EventBusModule : IServiceModule
+{
+    /// <summary>
+    ///     获取模块名称。
+    /// </summary>
+    public string ModuleName => nameof(EventBusModule);
+
+    /// <summary>
+    ///     获取模块优先级，数值越小优先级越高。
+    /// </summary>
+    public int Priority => 10;
+
+    /// <summary>
+    ///     获取模块启用状态，始终返回 true 表示该模块默认启用。
+    /// </summary>
+    public bool IsEnabled => true;
+
+    /// <summary>
+    ///     注册事件总线到依赖注入容器。
+    ///     创建事件总线实例并将其注册为多例服务。
+    /// </summary>
+    /// <param name="container">依赖注入容器实例。</param>
+    public void Register(IIocContainer container)
+    {
+        container.RegisterPlurality(new EventBus());
+    }
+
+    /// <summary>
+    ///     初始化模块。
+    ///     当前实现为空，因为事件总线无需额外初始化逻辑。
+    /// </summary>
+    public void Initialize()
+    {
+    }
+
+    /// <summary>
+    ///     异步销毁模块。
+    ///     当前实现为空，因为事件总线无需特殊销毁逻辑。
+    /// </summary>
+    /// <returns>表示异步操作完成的任务。</returns>
+    public ValueTask DestroyAsync()
+    {
+        return ValueTask.CompletedTask;
+    }
+}

GFramework.Core/services/modules/QueryExecutorModule.cs

@@ -0,0 +1,55 @@
+using GFramework.Core.Abstractions.architecture;
+using GFramework.Core.Abstractions.ioc;
+using GFramework.Core.query;
+
+namespace GFramework.Core.services.modules;
+
+/// <summary>
+///     查询执行器模块，用于注册和管理查询执行器服务。
+///     该模块负责将查询执行器注册到依赖注入容器中，并提供初始化和销毁功能。
+/// </summary>
+public sealed class QueryExecutorModule : IServiceModule
+{
+    /// <summary>
+    ///     获取模块名称。
+    /// </summary>
+    public string ModuleName => nameof(QueryExecutorModule);
+
+    /// <summary>
+    ///     获取模块优先级，数值越小优先级越高。
+    /// </summary>
+    public int Priority => 30;
+
+    /// <summary>
+    ///     获取模块启用状态，始终返回 true 表示该模块默认启用。
+    /// </summary>
+    public bool IsEnabled => true;
+
+    /// <summary>
+    ///     注册查询执行器到依赖注入容器。
+    ///     创建查询执行器实例并将其注册为多例服务。
+    /// </summary>
+    /// <param name="container">依赖注入容器实例。</param>
+    public void Register(IIocContainer container)
+    {
+        container.RegisterPlurality(new QueryExecutor());
+    }
+
+    /// <summary>
+    ///     初始化模块。
+    ///     当前实现为空，因为查询执行器无需额外初始化逻辑。
+    /// </summary>
+    public void Initialize()
+    {
+    }
+
+    /// <summary>
+    ///     异步销毁模块。
+    ///     当前实现为空，因为查询执行器无需特殊销毁逻辑。
+    /// </summary>
+    /// <returns>表示异步操作完成的任务。</returns>
+    public ValueTask DestroyAsync()
+    {
+        return ValueTask.CompletedTask;
+    }
+}