Merge pull request #174 from GeWuYou/feat/architecture-base-and-bootstrapper

Feat/architecture base and bootstrapper

GFramework.Core.Abstractions/Architectures/IArchitecture.cs

@@ -74,7 +74,9 @@ public interface IArchitecture : IAsyncInitializable, IAsyncDestroyable, IInitia
 
     /// <summary>
     ///     注册中介行为管道
-    ///     用于配置Mediator框架的行为拦截和处理逻辑
+    ///     用于配置Mediator框架的行为拦截和处理逻辑。
+    ///     既支持实现 <c>IPipelineBehavior&lt;,&gt;</c> 的开放泛型行为类型，
+    ///     也支持绑定到单一请求/响应对的封闭行为类型。
     /// </summary>
     /// <typeparam name="TBehavior">行为类型，必须是引用类型</typeparam>
     void RegisterMediatorBehavior<TBehavior>()

GFramework.Core.Tests/Architectures/ArchitectureComponentRegistryBehaviorTests.cs

@@ -0,0 +1,717 @@
+using GFramework.Core.Abstractions.Architectures;
+using GFramework.Core.Abstractions.Enums;
+using GFramework.Core.Abstractions.Model;
+using GFramework.Core.Abstractions.Systems;
+using GFramework.Core.Abstractions.Utility;
+using GFramework.Core.Architectures;
+using GFramework.Core.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GFramework.Core.Tests.Architectures;
+
+/// <summary>
+///     验证 Architecture 通过 <c>ArchitectureComponentRegistry</c> 暴露出的组件注册行为。
+///     这些测试覆盖实例注册、工厂注册、上下文注入、生命周期初始化和 Ready 后注册约束，
+///     用于保护组件注册器在继续重构后的既有契约。
+/// </summary>
+[TestFixture]
+public class ArchitectureComponentRegistryBehaviorTests
+{
+    /// <summary>
+    ///     初始化日志工厂和全局上下文状态。
+    /// </summary>
+    [SetUp]
+    public void SetUp()
+    {
+        LoggerFactoryResolver.Provider = new ConsoleLoggerFactoryProvider();
+        GameContext.Clear();
+    }
+
+    /// <summary>
+    ///     清理测试过程中绑定到全局表的架构上下文。
+    /// </summary>
+    [TearDown]
+    public void TearDown()
+    {
+        GameContext.Clear();
+    }
+
+    /// <summary>
+    ///     验证系统实例注册会注入上下文并参与生命周期初始化。
+    /// </summary>
+    [Test]
+    public async Task RegisterSystem_Instance_Should_Set_Context_And_Initialize_System()
+    {
+        var system = new TrackingSystem();
+        var architecture = new RegistryTestArchitecture(target => target.RegisterSystem(system));
+
+        await architecture.InitializeAsync();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(system.GetContext(), Is.SameAs(architecture.Context));
+            Assert.That(system.InitializeCallCount, Is.EqualTo(1));
+            Assert.That(architecture.Context.GetSystem<TrackingSystem>(), Is.SameAs(system));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证模型实例注册会注入上下文并参与生命周期初始化。
+    /// </summary>
+    [Test]
+    public async Task RegisterModel_Instance_Should_Set_Context_And_Initialize_Model()
+    {
+        var model = new TrackingModel();
+        var architecture = new RegistryTestArchitecture(target => target.RegisterModel(model));
+
+        await architecture.InitializeAsync();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(model.GetContext(), Is.SameAs(architecture.Context));
+            Assert.That(model.InitializeCallCount, Is.EqualTo(1));
+            Assert.That(architecture.Context.GetModel<TrackingModel>(), Is.SameAs(model));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证上下文工具注册会注入上下文并参与生命周期初始化。
+    /// </summary>
+    [Test]
+    public async Task RegisterUtility_Instance_Should_Set_Context_For_ContextUtility()
+    {
+        var utility = new TrackingContextUtility();
+        var architecture = new RegistryTestArchitecture(target => target.RegisterUtility(utility));
+
+        await architecture.InitializeAsync();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(utility.GetContext(), Is.SameAs(architecture.Context));
+            Assert.That(utility.InitializeCallCount, Is.EqualTo(1));
+            Assert.That(architecture.Context.GetUtility<TrackingContextUtility>(), Is.SameAs(utility));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证普通工具的工厂注册会在首次解析时创建单例并执行创建回调。
+    /// </summary>
+    [Test]
+    public async Task RegisterUtility_Type_Should_Create_Singleton_And_Invoke_Callback()
+    {
+        FactoryCreatedUtility? callbackInstance = null;
+        var architecture = new RegistryTestArchitecture(target =>
+            target.RegisterUtility<FactoryCreatedUtility>(created => callbackInstance = created));
+
+        await architecture.InitializeAsync();
+
+        var first = architecture.Context.GetUtility<FactoryCreatedUtility>();
+        var second = architecture.Context.GetUtility<FactoryCreatedUtility>();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(callbackInstance, Is.SameAs(first));
+            Assert.That(second, Is.SameAs(first));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证系统类型注册会在初始化期间物化实例、注入构造函数依赖并执行创建回调。
+    /// </summary>
+    [Test]
+    public async Task RegisterSystem_Type_Should_Create_Instance_During_Initialization()
+    {
+        var dependency = new ConstructorDependency("system-dependency");
+        FactoryCreatedSystem? callbackInstance = null;
+        var architecture = new RegistryTestArchitecture(
+            target => target.RegisterSystem<FactoryCreatedSystem>(created => callbackInstance = created),
+            services => services.AddSingleton(dependency));
+
+        await architecture.InitializeAsync();
+
+        var resolved = architecture.Context.GetSystem<FactoryCreatedSystem>();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(callbackInstance, Is.Not.Null);
+            Assert.That(resolved, Is.SameAs(callbackInstance));
+            Assert.That(resolved.Dependency, Is.SameAs(dependency));
+            Assert.That(resolved.GetContext(), Is.SameAs(architecture.Context));
+            Assert.That(resolved.InitializeCallCount, Is.EqualTo(1));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证模型类型注册会在初始化期间物化实例、注入构造函数依赖并执行创建回调。
+    /// </summary>
+    [Test]
+    public async Task RegisterModel_Type_Should_Create_Instance_During_Initialization()
+    {
+        var dependency = new ConstructorDependency("model-dependency");
+        FactoryCreatedModel? callbackInstance = null;
+        var architecture = new RegistryTestArchitecture(
+            target => target.RegisterModel<FactoryCreatedModel>(created => callbackInstance = created),
+            services => services.AddSingleton(dependency));
+
+        await architecture.InitializeAsync();
+
+        var resolved = architecture.Context.GetModel<FactoryCreatedModel>();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(callbackInstance, Is.Not.Null);
+            Assert.That(resolved, Is.SameAs(callbackInstance));
+            Assert.That(resolved.Dependency, Is.SameAs(dependency));
+            Assert.That(resolved.GetContext(), Is.SameAs(architecture.Context));
+            Assert.That(resolved.InitializeCallCount, Is.EqualTo(1));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证预冻结阶段通过实现类型注册的单例依赖会在同一轮组件激活中复用同一个实例。
+    ///     该回归测试用于保护 <see cref="ArchitectureComponentActivator" /> 的共享单例缓存，避免系统和模型分别创建重复单例。
+    /// </summary>
+    [Test]
+    public async Task RegisterSystem_And_Model_Type_Should_Reuse_ImplementationType_Singleton_During_Activation()
+    {
+        var counter = new DependencyConstructionCounter();
+        var architecture = new RegistryTestArchitecture(
+            target =>
+            {
+                target.RegisterSystem<ImplementationTypeDependencySystem>();
+                target.RegisterModel<ImplementationTypeDependencyModel>();
+            },
+            services =>
+            {
+                services.AddSingleton(counter);
+                services.AddSingleton<ImplementationTypeSharedDependency>();
+            });
+
+        await architecture.InitializeAsync();
+
+        var system = architecture.Context.GetSystem<ImplementationTypeDependencySystem>();
+        var model = architecture.Context.GetModel<ImplementationTypeDependencyModel>();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(counter.CreationCount, Is.EqualTo(1));
+            Assert.That(system.Dependency, Is.SameAs(model.Dependency));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证预冻结阶段通过工厂注册的单例依赖会在同一轮组件激活中复用同一个实例。
+    ///     该回归测试覆盖 <c>ImplementationFactory</c> 描述符路径，避免用户工厂在初始化时被重复调用。
+    /// </summary>
+    [Test]
+    public async Task RegisterSystem_And_Model_Type_Should_Reuse_Factory_Singleton_During_Activation()
+    {
+        var creationCount = 0;
+        var architecture = new RegistryTestArchitecture(
+            target =>
+            {
+                target.RegisterSystem<FactoryDependencySystem>();
+                target.RegisterModel<FactoryDependencyModel>();
+            },
+            services =>
+            {
+                services.AddSingleton(_ =>
+                {
+                    creationCount++;
+                    return new FactorySharedDependency();
+                });
+            });
+
+        await architecture.InitializeAsync();
+
+        var system = architecture.Context.GetSystem<FactoryDependencySystem>();
+        var model = architecture.Context.GetModel<FactoryDependencyModel>();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(creationCount, Is.EqualTo(1));
+            Assert.That(system.Dependency, Is.SameAs(model.Dependency));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证 Ready 阶段后不允许继续注册 Utility，保持与系统和模型一致的约束。
+    /// </summary>
+    [Test]
+    public async Task RegisterUtility_After_Ready_Should_Throw_InvalidOperationException()
+    {
+        var architecture = new RegistryTestArchitecture(_ => { });
+        await architecture.InitializeAsync();
+
+        Assert.That(
+            () => architecture.RegisterUtility(new TrackingContextUtility()),
+            Throws.InvalidOperationException.With.Message.EqualTo(
+                "Cannot register utility after Architecture is Ready"));
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     用于测试组件注册行为的最小架构实现。
+    /// </summary>
+    private sealed class RegistryTestArchitecture : Architecture
+    {
+        private readonly Action<IServiceCollection>? _configurator;
+        private readonly Action<RegistryTestArchitecture> _registrationAction;
+
+        /// <summary>
+        ///     创建一个可选地附带服务配置逻辑的测试架构。
+        /// </summary>
+        /// <param name="registrationAction">初始化阶段执行的组件注册逻辑。</param>
+        /// <param name="configurator">初始化前执行的服务配置逻辑。</param>
+        public RegistryTestArchitecture(
+            Action<RegistryTestArchitecture> registrationAction,
+            Action<IServiceCollection>? configurator = null)
+        {
+            _registrationAction = registrationAction;
+            _configurator = configurator;
+        }
+
+        /// <summary>
+        ///     返回测试注入的服务配置逻辑。
+        /// </summary>
+        public override Action<IServiceCollection>? Configurator => _configurator;
+
+        /// <summary>
+        ///     在初始化阶段执行测试注入的注册逻辑。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+            _registrationAction(this);
+        }
+    }
+
+    /// <summary>
+    ///     记录初始化与上下文注入情况的测试系统。
+    /// </summary>
+    private sealed class TrackingSystem : ISystem
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取系统初始化调用次数。
+        /// </summary>
+        public int InitializeCallCount { get; private set; }
+
+        /// <summary>
+        ///     记录初始化调用。
+        /// </summary>
+        public void Initialize()
+        {
+            InitializeCallCount++;
+        }
+
+        /// <summary>
+        ///     该测试系统不关心阶段变更。
+        /// </summary>
+        /// <param name="phase">当前架构阶段。</param>
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        /// <summary>
+        ///     存储注入的架构上下文。
+        /// </summary>
+        /// <param name="context">架构上下文。</param>
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        /// <summary>
+        ///     返回当前持有的架构上下文。
+        /// </summary>
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+
+        /// <summary>
+        ///     该测试系统没有额外销毁逻辑。
+        /// </summary>
+        public void Destroy()
+        {
+        }
+    }
+
+    /// <summary>
+    ///     记录初始化与上下文注入情况的测试模型。
+    /// </summary>
+    private sealed class TrackingModel : IModel
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取模型初始化调用次数。
+        /// </summary>
+        public int InitializeCallCount { get; private set; }
+
+        /// <summary>
+        ///     记录初始化调用。
+        /// </summary>
+        public void Initialize()
+        {
+            InitializeCallCount++;
+        }
+
+        /// <summary>
+        ///     该测试模型不关心阶段变更。
+        /// </summary>
+        /// <param name="phase">当前架构阶段。</param>
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        /// <summary>
+        ///     存储注入的架构上下文。
+        /// </summary>
+        /// <param name="context">架构上下文。</param>
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        /// <summary>
+        ///     返回当前持有的架构上下文。
+        /// </summary>
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     记录初始化与上下文注入情况的测试上下文工具。
+    /// </summary>
+    private sealed class TrackingContextUtility : IContextUtility
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取工具初始化调用次数。
+        /// </summary>
+        public int InitializeCallCount { get; private set; }
+
+        /// <summary>
+        ///     记录初始化调用。
+        /// </summary>
+        public void Initialize()
+        {
+            InitializeCallCount++;
+        }
+
+        /// <summary>
+        ///     存储注入的架构上下文。
+        /// </summary>
+        /// <param name="context">架构上下文。</param>
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        /// <summary>
+        ///     返回当前持有的架构上下文。
+        /// </summary>
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+
+        /// <summary>
+        ///     该测试工具没有额外销毁逻辑。
+        /// </summary>
+        public void Destroy()
+        {
+        }
+    }
+
+    /// <summary>
+    ///     用于验证普通工厂注册路径的简单工具。
+    /// </summary>
+    private sealed class FactoryCreatedUtility : IUtility
+    {
+    }
+
+    /// <summary>
+    ///     用于验证构造函数依赖注入的简单依赖对象。
+    /// </summary>
+    private sealed class ConstructorDependency(string name)
+    {
+        /// <summary>
+        ///     获取依赖对象名称。
+        /// </summary>
+        public string Name { get; } = name;
+    }
+
+    /// <summary>
+    ///     用于验证系统类型注册路径的工厂创建系统。
+    /// </summary>
+    private sealed class FactoryCreatedSystem(ConstructorDependency dependency) : ISystem
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取构造函数注入的依赖对象。
+        /// </summary>
+        public ConstructorDependency Dependency { get; } = dependency;
+
+        /// <summary>
+        ///     获取初始化调用次数。
+        /// </summary>
+        public int InitializeCallCount { get; private set; }
+
+        public void Initialize()
+        {
+            InitializeCallCount++;
+        }
+
+        public void Destroy()
+        {
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     用于验证模型类型注册路径的工厂创建模型。
+    /// </summary>
+    private sealed class FactoryCreatedModel(ConstructorDependency dependency) : IModel
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取构造函数注入的依赖对象。
+        /// </summary>
+        public ConstructorDependency Dependency { get; } = dependency;
+
+        /// <summary>
+        ///     获取初始化调用次数。
+        /// </summary>
+        public int InitializeCallCount { get; private set; }
+
+        public void Initialize()
+        {
+            InitializeCallCount++;
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     统计实现类型单例在预冻结激活阶段的构造次数。
+    /// </summary>
+    private sealed class DependencyConstructionCounter
+    {
+        /// <summary>
+        ///     获取共享依赖被构造的次数。
+        /// </summary>
+        public int CreationCount { get; private set; }
+
+        /// <summary>
+        ///     记录一次新的依赖构造。
+        /// </summary>
+        public void RecordCreation()
+        {
+            CreationCount++;
+        }
+    }
+
+    /// <summary>
+    ///     用于覆盖 ImplementationType 单例描述符路径的共享依赖。
+    /// </summary>
+    private sealed class ImplementationTypeSharedDependency
+    {
+        /// <summary>
+        ///     创建共享依赖并记录构造次数。
+        /// </summary>
+        /// <param name="counter">用于统计构造次数的计数器。</param>
+        public ImplementationTypeSharedDependency(DependencyConstructionCounter counter)
+        {
+            counter.RecordCreation();
+        }
+    }
+
+    /// <summary>
+    ///     用于覆盖 ImplementationType 单例复用路径的测试系统。
+    /// </summary>
+    private sealed class ImplementationTypeDependencySystem(ImplementationTypeSharedDependency dependency) : ISystem
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取构造函数注入的共享依赖。
+        /// </summary>
+        public ImplementationTypeSharedDependency Dependency { get; } = dependency;
+
+        public void Initialize()
+        {
+        }
+
+        public void Destroy()
+        {
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     用于覆盖 ImplementationType 单例复用路径的测试模型。
+    /// </summary>
+    private sealed class ImplementationTypeDependencyModel(ImplementationTypeSharedDependency dependency) : IModel
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取构造函数注入的共享依赖。
+        /// </summary>
+        public ImplementationTypeSharedDependency Dependency { get; } = dependency;
+
+        public void Initialize()
+        {
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     用于覆盖 ImplementationFactory 单例描述符路径的共享依赖。
+    /// </summary>
+    private sealed class FactorySharedDependency
+    {
+    }
+
+    /// <summary>
+    ///     用于覆盖 ImplementationFactory 单例复用路径的测试系统。
+    /// </summary>
+    private sealed class FactoryDependencySystem(FactorySharedDependency dependency) : ISystem
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取构造函数注入的共享依赖。
+        /// </summary>
+        public FactorySharedDependency Dependency { get; } = dependency;
+
+        public void Initialize()
+        {
+        }
+
+        public void Destroy()
+        {
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     用于覆盖 ImplementationFactory 单例复用路径的测试模型。
+    /// </summary>
+    private sealed class FactoryDependencyModel(FactorySharedDependency dependency) : IModel
+    {
+        private IArchitectureContext _context = null!;
+
+        /// <summary>
+        ///     获取构造函数注入的共享依赖。
+        /// </summary>
+        public FactorySharedDependency Dependency { get; } = dependency;
+
+        public void Initialize()
+        {
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+}

GFramework.Core.Tests/Architectures/ArchitectureInitializationPipelineTests.cs

@@ -0,0 +1,188 @@
+using GFramework.Core.Abstractions.Enums;
+using GFramework.Core.Abstractions.Events;
+using GFramework.Core.Architectures;
+using GFramework.Core.Environment;
+using GFramework.Core.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GFramework.Core.Tests.Architectures;
+
+/// <summary>
+///     验证 <see cref="Architecture" /> 初始化编排流程的单元测试。
+///     这些测试覆盖环境初始化、服务准备、上下文绑定和自定义服务配置的时序，
+///     以确保核心协调器在拆分后仍保持既有行为。
+/// </summary>
+[TestFixture]
+public class ArchitectureInitializationPipelineTests
+{
+    /// <summary>
+    ///     为每个测试准备独立的日志工厂和游戏上下文状态。
+    /// </summary>
+    [SetUp]
+    public void SetUp()
+    {
+        LoggerFactoryResolver.Provider = new ConsoleLoggerFactoryProvider();
+        GameContext.Clear();
+    }
+
+    /// <summary>
+    ///     清理测试期间注册的全局游戏上下文，避免跨测试污染。
+    /// </summary>
+    [TearDown]
+    public void TearDown()
+    {
+        GameContext.Clear();
+    }
+
+    /// <summary>
+    ///     验证异步初始化会在执行用户初始化逻辑之前准备环境、服务和上下文。
+    /// </summary>
+    [Test]
+    public async Task InitializeAsync_Should_Prepare_Runtime_Before_OnInitialize()
+    {
+        var environment = new TrackingEnvironment();
+        var marker = new BootstrapMarker();
+        var architecture = new InitializationPipelineTestArchitecture(environment, marker);
+
+        await architecture.InitializeAsync();
+
+        AssertRuntimePrepared(architecture, environment, marker);
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证同步初始化路径复用同一套基础设施准备流程。
+    /// </summary>
+    [Test]
+    public async Task Initialize_Should_Prepare_Runtime_Before_OnInitialize()
+    {
+        var environment = new TrackingEnvironment();
+        var marker = new BootstrapMarker();
+        var architecture = new InitializationPipelineTestArchitecture(environment, marker);
+
+        architecture.Initialize();
+
+        AssertRuntimePrepared(architecture, environment, marker);
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     断言初始化阶段所需的运行时准备工作都已经完成。
+    /// </summary>
+    /// <param name="architecture">待验证的测试架构实例。</param>
+    /// <param name="environment">测试使用的环境对象。</param>
+    /// <param name="marker">通过服务配置委托注册的标记服务。</param>
+    private static void AssertRuntimePrepared(
+        InitializationPipelineTestArchitecture architecture,
+        TrackingEnvironment environment,
+        BootstrapMarker marker)
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(architecture.ObservedEnvironmentInitialized, Is.True);
+            Assert.That(architecture.ObservedConfiguredServiceAvailable, Is.True);
+            Assert.That(architecture.ObservedEventBusAvailable, Is.True);
+            Assert.That(architecture.ObservedContextWasBound, Is.True);
+            Assert.That(architecture.ObservedEnvironmentRegistered, Is.True);
+            Assert.That(architecture.Context.GetEnvironment(), Is.SameAs(environment));
+            Assert.That(architecture.Context.GetService<BootstrapMarker>(), Is.SameAs(marker));
+            Assert.That(architecture.CurrentPhase, Is.EqualTo(ArchitecturePhase.Ready));
+        });
+    }
+
+    /// <summary>
+    ///     跟踪初始化期间关键可观察状态的测试架构。
+    /// </summary>
+    private sealed class InitializationPipelineTestArchitecture : Architecture
+    {
+        private readonly TrackingEnvironment _environment;
+        private readonly BootstrapMarker _marker;
+
+        /// <summary>
+        ///     使用可观察环境和标记服务创建测试架构。
+        /// </summary>
+        /// <param name="environment">用于验证初始化时序的环境对象。</param>
+        /// <param name="marker">用于验证服务钩子执行结果的标记服务。</param>
+        public InitializationPipelineTestArchitecture(
+            TrackingEnvironment environment,
+            BootstrapMarker marker)
+            : base(environment: environment)
+        {
+            _environment = environment;
+            _marker = marker;
+        }
+
+        /// <summary>
+        ///     记录用户初始化逻辑执行时环境是否已经准备完成。
+        /// </summary>
+        public bool ObservedEnvironmentInitialized { get; private set; }
+
+        /// <summary>
+        ///     记录自定义服务是否已在用户初始化前注册到容器。
+        /// </summary>
+        public bool ObservedConfiguredServiceAvailable { get; private set; }
+
+        /// <summary>
+        ///     记录内置事件总线是否已在用户初始化前可用。
+        /// </summary>
+        public bool ObservedEventBusAvailable { get; private set; }
+
+        /// <summary>
+        ///     记录当前上下文是否已在用户初始化前绑定到全局游戏上下文表。
+        /// </summary>
+        public bool ObservedContextWasBound { get; private set; }
+
+        /// <summary>
+        ///     记录环境对象是否已在用户初始化前注册到架构上下文。
+        /// </summary>
+        public bool ObservedEnvironmentRegistered { get; private set; }
+
+        /// <summary>
+        ///     为容器注册测试标记服务，用于验证初始化前的服务钩子是否执行。
+        /// </summary>
+        public override Action<IServiceCollection>? Configurator => services => services.AddSingleton(_marker);
+
+        /// <summary>
+        ///     在用户初始化逻辑中采集运行时准备状态。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+            ObservedEnvironmentInitialized = _environment.InitializeCallCount == 1;
+            ObservedConfiguredServiceAvailable = ReferenceEquals(Context.GetService<BootstrapMarker>(), _marker);
+            ObservedEventBusAvailable = Context.GetService<IEventBus>() is not null;
+            ObservedContextWasBound = ReferenceEquals(GameContext.GetByType(GetType()), Context);
+            ObservedEnvironmentRegistered = ReferenceEquals(Context.GetEnvironment(), _environment);
+        }
+    }
+
+    /// <summary>
+    ///     用于验证环境初始化是否发生的测试环境。
+    /// </summary>
+    private sealed class TrackingEnvironment : EnvironmentBase
+    {
+        /// <summary>
+        ///     获取测试环境名称。
+        /// </summary>
+        public override string Name { get; } = "Tracking";
+
+        /// <summary>
+        ///     获取环境初始化调用次数。
+        /// </summary>
+        public int InitializeCallCount { get; private set; }
+
+        /// <summary>
+        ///     记录环境初始化次数。
+        /// </summary>
+        public override void Initialize()
+        {
+            InitializeCallCount++;
+        }
+    }
+
+    /// <summary>
+    ///     通过服务配置委托注册到容器的测试标记对象。
+    /// </summary>
+    private sealed class BootstrapMarker
+    {
+    }
+}

GFramework.Core.Tests/Architectures/ArchitectureLifecycleBehaviorTests.cs

@@ -0,0 +1,463 @@
+using System.Reflection;
+using GFramework.Core.Abstractions.Architectures;
+using GFramework.Core.Abstractions.Enums;
+using GFramework.Core.Abstractions.Lifecycle;
+using GFramework.Core.Abstractions.Model;
+using GFramework.Core.Abstractions.Systems;
+using GFramework.Core.Abstractions.Utility;
+using GFramework.Core.Architectures;
+using GFramework.Core.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GFramework.Core.Tests.Architectures;
+
+/// <summary>
+///     验证 Architecture 生命周期行为的集成测试。
+///     这些测试覆盖阶段流转、失败状态传播和逆序销毁规则，
+///     用于保护拆分后的生命周期管理、阶段协调与销毁协调行为。
+/// </summary>
+[TestFixture]
+public class ArchitectureLifecycleBehaviorTests
+{
+    /// <summary>
+    ///     为每个测试准备独立的日志工厂和全局上下文状态。
+    /// </summary>
+    [SetUp]
+    public void SetUp()
+    {
+        LoggerFactoryResolver.Provider = new ConsoleLoggerFactoryProvider();
+        GameContext.Clear();
+    }
+
+    /// <summary>
+    ///     清理测试注册到全局上下文表的架构上下文。
+    /// </summary>
+    [TearDown]
+    public void TearDown()
+    {
+        GameContext.Clear();
+    }
+
+    /// <summary>
+    ///     验证初始化流程会按既定顺序推进所有生命周期阶段。
+    /// </summary>
+    [Test]
+    public async Task InitializeAsync_Should_Enter_Expected_Phases_In_Order()
+    {
+        var architecture = new PhaseTrackingArchitecture();
+
+        await architecture.InitializeAsync();
+
+        Assert.That(architecture.PhaseHistory, Is.EqualTo(new[]
+        {
+            ArchitecturePhase.BeforeUtilityInit,
+            ArchitecturePhase.AfterUtilityInit,
+            ArchitecturePhase.BeforeModelInit,
+            ArchitecturePhase.AfterModelInit,
+            ArchitecturePhase.BeforeSystemInit,
+            ArchitecturePhase.AfterSystemInit,
+            ArchitecturePhase.Ready
+        }));
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证用户初始化失败时，等待 Ready 的任务会失败并进入 FailedInitialization 阶段。
+    /// </summary>
+    [Test]
+    public async Task InitializeAsync_When_OnInitialize_Throws_Should_Mark_FailedInitialization()
+    {
+        var architecture = new PhaseTrackingArchitecture(() => throw new InvalidOperationException("boom"));
+
+        var exception = Assert.ThrowsAsync<InvalidOperationException>(async () => await architecture.InitializeAsync());
+        Assert.That(exception, Is.Not.Null);
+        Assert.That(architecture.CurrentPhase, Is.EqualTo(ArchitecturePhase.FailedInitialization));
+        Assert.ThrowsAsync<InvalidOperationException>(async () => await architecture.WaitUntilReadyAsync());
+    }
+
+    /// <summary>
+    ///     验证销毁流程会按注册逆序释放组件，并推进 Destroying/Destroyed 阶段。
+    /// </summary>
+    [Test]
+    public async Task DestroyAsync_Should_Destroy_Components_In_Reverse_Registration_Order()
+    {
+        var destroyOrder = new List<string>();
+        var architecture = new DestroyOrderArchitecture(destroyOrder);
+
+        await architecture.InitializeAsync();
+        await architecture.DestroyAsync();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(destroyOrder, Is.EqualTo(new[] { "system", "model", "utility" }));
+            Assert.That(architecture.CurrentPhase, Is.EqualTo(ArchitecturePhase.Destroyed));
+            Assert.That(architecture.PhaseHistory[^2..], Is.EqualTo(new[]
+            {
+                ArchitecturePhase.Destroying,
+                ArchitecturePhase.Destroyed
+            }));
+        });
+    }
+
+    /// <summary>
+    ///     验证初始化失败后仍然允许执行销毁流程。
+    ///     该回归测试用于保护 FailedInitialization → Destroying 的合法迁移，避免失败路径上的组件与容器泄漏。
+    /// </summary>
+    [Test]
+    public async Task DestroyAsync_After_FailedInitialization_Should_Cleanup_And_Enter_Destroyed()
+    {
+        var destroyOrder = new List<string>();
+        var architecture = new FailingInitializationArchitecture(destroyOrder);
+
+        var exception = Assert.ThrowsAsync<InvalidOperationException>(async () => await architecture.InitializeAsync());
+        Assert.That(exception, Is.Not.Null);
+        Assert.That(architecture.CurrentPhase, Is.EqualTo(ArchitecturePhase.FailedInitialization));
+
+        await architecture.DestroyAsync();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(destroyOrder, Is.EqualTo(new[] { "model", "utility" }));
+            Assert.That(architecture.CurrentPhase, Is.EqualTo(ArchitecturePhase.Destroyed));
+            Assert.That(architecture.PhaseHistory[^3..], Is.EqualTo(new[]
+            {
+                ArchitecturePhase.FailedInitialization,
+                ArchitecturePhase.Destroying,
+                ArchitecturePhase.Destroyed
+            }));
+        });
+    }
+
+    /// <summary>
+    ///     验证 Destroyed 阶段会在容器清空前广播给容器内的阶段监听器。
+    ///     该回归测试保护销毁尾声的阶段通知，确保依赖最终阶段信号的服务仍能收到 Destroyed。
+    /// </summary>
+    [Test]
+    public async Task DestroyAsync_Should_Notify_Container_Phase_Listeners_About_Destroyed_Before_Clear()
+    {
+        var listener = new TrackingPhaseListener();
+        var architecture = new ListenerTrackingArchitecture(listener);
+
+        await architecture.InitializeAsync();
+        await architecture.DestroyAsync();
+
+        Assert.That(listener.ObservedPhases[^2..], Is.EqualTo(new[]
+        {
+            ArchitecturePhase.Destroying,
+            ArchitecturePhase.Destroyed
+        }));
+    }
+
+    /// <summary>
+    ///     验证启用 AllowLateRegistration 时，生命周期层会立即初始化后注册的组件，而不是继续沿用初始化期的拒绝策略。
+    ///     由于公共架构 API 在 Ready 之后会先触发容器限制，此回归测试直接覆盖生命周期协作者的对齐逻辑。
+    /// </summary>
+    [Test]
+    public async Task
+        RegisterLifecycleComponent_After_Initialization_Should_Initialize_Immediately_When_LateRegistration_Is_Enabled()
+    {
+        var architecture = new AllowLateRegistrationArchitecture();
+        await architecture.InitializeAsync();
+
+        var lateComponent = new LateRegisteredInitializableComponent();
+
+        architecture.RegisterLateComponentForTesting(lateComponent);
+
+        Assert.That(lateComponent.InitializeCallCount, Is.EqualTo(1));
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     记录阶段流转的可配置测试架构。
+    /// </summary>
+    private sealed class PhaseTrackingArchitecture : Architecture
+    {
+        private readonly Action? _onInitializeAction;
+
+        /// <summary>
+        ///     创建一个可选地在用户初始化阶段执行自定义逻辑的测试架构。
+        /// </summary>
+        /// <param name="onInitializeAction">用户初始化时执行的测试回调。</param>
+        public PhaseTrackingArchitecture(Action? onInitializeAction = null)
+        {
+            _onInitializeAction = onInitializeAction;
+            PhaseChanged += phase => PhaseHistory.Add(phase);
+        }
+
+        /// <summary>
+        ///     获取架构经历过的阶段列表。
+        /// </summary>
+        public List<ArchitecturePhase> PhaseHistory { get; } = [];
+
+        /// <summary>
+        ///     执行测试注入的初始化逻辑。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+            _onInitializeAction?.Invoke();
+        }
+    }
+
+    /// <summary>
+    ///     在初始化时注册可销毁组件的测试架构。
+    /// </summary>
+    private sealed class DestroyOrderArchitecture : Architecture
+    {
+        private readonly List<string> _destroyOrder;
+
+        /// <summary>
+        ///     创建用于验证销毁顺序的测试架构。
+        /// </summary>
+        /// <param name="destroyOrder">记录组件销毁顺序的列表。</param>
+        public DestroyOrderArchitecture(List<string> destroyOrder)
+        {
+            _destroyOrder = destroyOrder;
+            PhaseChanged += phase => PhaseHistory.Add(phase);
+        }
+
+        /// <summary>
+        ///     获取架构经历过的阶段列表。
+        /// </summary>
+        public List<ArchitecturePhase> PhaseHistory { get; } = [];
+
+        /// <summary>
+        ///     注册会记录销毁顺序的 Utility、Model 和 System。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+            RegisterUtility(new TrackingDestroyableUtility(_destroyOrder));
+            RegisterModel(new TrackingDestroyableModel(_destroyOrder));
+            RegisterSystem(new TrackingDestroyableSystem(_destroyOrder));
+        }
+    }
+
+    /// <summary>
+    ///     在初始化阶段注册可销毁组件并随后抛出异常的测试架构。
+    /// </summary>
+    private sealed class FailingInitializationArchitecture : Architecture
+    {
+        private readonly List<string> _destroyOrder;
+
+        /// <summary>
+        ///     创建用于验证失败后销毁行为的测试架构。
+        /// </summary>
+        /// <param name="destroyOrder">记录失败后清理顺序的列表。</param>
+        public FailingInitializationArchitecture(List<string> destroyOrder)
+        {
+            _destroyOrder = destroyOrder;
+            PhaseChanged += phase => PhaseHistory.Add(phase);
+        }
+
+        /// <summary>
+        ///     获取架构经历过的阶段列表。
+        /// </summary>
+        public List<ArchitecturePhase> PhaseHistory { get; } = [];
+
+        /// <summary>
+        ///     注册可销毁组件后故意抛出异常，模拟初始化失败场景。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+            RegisterUtility(new TrackingDestroyableUtility(_destroyOrder));
+            RegisterModel(new TrackingDestroyableModel(_destroyOrder));
+            throw new InvalidOperationException("boom");
+        }
+    }
+
+    /// <summary>
+    ///     通过配置器把阶段监听器注册到容器中的测试架构。
+    /// </summary>
+    private sealed class ListenerTrackingArchitecture(TrackingPhaseListener listener) : Architecture
+    {
+        /// <summary>
+        ///     保持对监听器的引用，以便配置器在初始化前把同一实例注册到容器。
+        /// </summary>
+        public override Action<IServiceCollection>? Configurator =>
+            services => services.AddSingleton<IArchitecturePhaseListener>(listener);
+
+        /// <summary>
+        ///     该测试不需要额外组件注册。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+        }
+    }
+
+    /// <summary>
+    ///     启用 AllowLateRegistration 的测试架构。
+    ///     该架构暴露生命周期协作者供回归测试验证内部注册策略对齐。
+    /// </summary>
+    private sealed class AllowLateRegistrationArchitecture : Architecture
+    {
+        /// <summary>
+        ///     使用允许后注册的配置创建测试架构。
+        /// </summary>
+        public AllowLateRegistrationArchitecture()
+            : base(new ArchitectureConfiguration
+            {
+                ArchitectureProperties = new()
+                {
+                    AllowLateRegistration = true,
+                    StrictPhaseValidation = true
+                }
+            })
+        {
+        }
+
+        /// <summary>
+        ///     该测试不需要初始组件。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+        }
+
+        /// <summary>
+        ///     通过反射调用内部生命周期协作者的注册逻辑，以便覆盖无法通过公共 API 直接到达的后注册初始化路径。
+        /// </summary>
+        /// <param name="component">要登记到生命周期中的后注册组件。</param>
+        public void RegisterLateComponentForTesting(object component)
+        {
+            var field = typeof(Architecture).GetField(
+                "_lifecycle",
+                BindingFlags.Instance | BindingFlags.NonPublic);
+            var lifecycle = field?.GetValue(this) ??
+                            throw new InvalidOperationException("Architecture lifecycle field was not found.");
+            var registerMethod = lifecycle.GetType().GetMethod(nameof(RegisterLateComponentForTesting)) ??
+                                 lifecycle.GetType().GetMethod("RegisterLifecycleComponent") ??
+                                 throw new InvalidOperationException(
+                                     "Architecture lifecycle registration method was not found.");
+
+            registerMethod.Invoke(lifecycle, [component]);
+        }
+    }
+
+    /// <summary>
+    ///     用于验证逆序销毁的上下文工具。
+    /// </summary>
+    private sealed class TrackingDestroyableUtility(List<string> destroyOrder) : IContextUtility
+    {
+        private IArchitectureContext _context = null!;
+
+        public void Initialize()
+        {
+        }
+
+        public void Destroy()
+        {
+            destroyOrder.Add("utility");
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     记录容器阶段通知顺序的监听器。
+    /// </summary>
+    private sealed class TrackingPhaseListener : IArchitecturePhaseListener
+    {
+        /// <summary>
+        ///     获取监听到的阶段列表。
+        /// </summary>
+        public List<ArchitecturePhase> ObservedPhases { get; } = [];
+
+        /// <summary>
+        ///     记录收到的阶段通知。
+        /// </summary>
+        /// <param name="phase">当前阶段。</param>
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+            ObservedPhases.Add(phase);
+        }
+    }
+
+    /// <summary>
+    ///     记录即时初始化次数的后注册测试组件。
+    /// </summary>
+    private sealed class LateRegisteredInitializableComponent : IInitializable
+    {
+        /// <summary>
+        ///     获取组件被即时初始化的次数。
+        /// </summary>
+        public int InitializeCallCount { get; private set; }
+
+        /// <summary>
+        ///     记录一次初始化调用。
+        /// </summary>
+        public void Initialize()
+        {
+            InitializeCallCount++;
+        }
+    }
+
+    /// <summary>
+    ///     用于验证逆序销毁的模型。
+    /// </summary>
+    private sealed class TrackingDestroyableModel(List<string> destroyOrder) : IModel, IDestroyable
+    {
+        private IArchitectureContext _context = null!;
+
+        public void Destroy()
+        {
+            destroyOrder.Add("model");
+        }
+
+        public void Initialize()
+        {
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+
+    /// <summary>
+    ///     用于验证逆序销毁的系统。
+    /// </summary>
+    private sealed class TrackingDestroyableSystem(List<string> destroyOrder) : ISystem
+    {
+        private IArchitectureContext _context = null!;
+
+        public void Initialize()
+        {
+        }
+
+        public void Destroy()
+        {
+            destroyOrder.Add("system");
+        }
+
+        public void OnArchitecturePhase(ArchitecturePhase phase)
+        {
+        }
+
+        public void SetContext(IArchitectureContext context)
+        {
+            _context = context;
+        }
+
+        public IArchitectureContext GetContext()
+        {
+            return _context;
+        }
+    }
+}

GFramework.Core.Tests/Architectures/ArchitectureModulesBehaviorTests.cs

@@ -0,0 +1,188 @@
+using GFramework.Core.Abstractions.Architectures;
+using GFramework.Core.Abstractions.Utility;
+using GFramework.Core.Architectures;
+using GFramework.Core.Logging;
+using Mediator;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GFramework.Core.Tests.Architectures;
+
+/// <summary>
+///     验证 Architecture 通过 <c>ArchitectureModules</c> 暴露出的模块安装与 Mediator 行为注册能力。
+///     这些测试覆盖模块安装回调和中介管道行为接入，确保模块管理器仍然保持可观察行为不变。
+/// </summary>
+[TestFixture]
+public class ArchitectureModulesBehaviorTests
+{
+    /// <summary>
+    ///     初始化日志工厂和全局上下文状态。
+    /// </summary>
+    [SetUp]
+    public void SetUp()
+    {
+        LoggerFactoryResolver.Provider = new ConsoleLoggerFactoryProvider();
+        GameContext.Clear();
+        TrackingPipelineBehavior<ModuleBehaviorRequest, string>.InvocationCount = 0;
+    }
+
+    /// <summary>
+    ///     清理测试过程中写入的全局上下文状态。
+    /// </summary>
+    [TearDown]
+    public void TearDown()
+    {
+        GameContext.Clear();
+        TrackingPipelineBehavior<ModuleBehaviorRequest, string>.InvocationCount = 0;
+    }
+
+    /// <summary>
+    ///     验证安装模块时会把当前架构实例传给模块，并允许模块在安装阶段注册组件。
+    /// </summary>
+    [Test]
+    public async Task InstallModule_Should_Invoke_Module_Install_With_Current_Architecture()
+    {
+        var module = new TrackingArchitectureModule();
+        var architecture = new ModuleTestArchitecture(target => target.InstallModule(module));
+
+        await architecture.InitializeAsync();
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(module.InstalledArchitecture, Is.SameAs(architecture));
+            Assert.That(module.InstallCallCount, Is.EqualTo(1));
+            Assert.That(architecture.Context.GetUtility<InstalledByModuleUtility>(), Is.Not.Null);
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     验证注册的 Mediator 行为会参与请求管道执行。
+    /// </summary>
+    [Test]
+    public async Task RegisterMediatorBehavior_Should_Apply_Pipeline_Behavior_To_Request()
+    {
+        var architecture = new ModuleTestArchitecture(target =>
+            target.RegisterMediatorBehavior<TrackingPipelineBehavior<ModuleBehaviorRequest, string>>());
+
+        await architecture.InitializeAsync();
+
+        var response = await architecture.Context.SendRequestAsync(new ModuleBehaviorRequest());
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(response, Is.EqualTo("handled"));
+            Assert.That(TrackingPipelineBehavior<ModuleBehaviorRequest, string>.InvocationCount, Is.EqualTo(1));
+        });
+
+        await architecture.DestroyAsync();
+    }
+
+    /// <summary>
+    ///     用于测试模块行为的最小架构实现。
+    /// </summary>
+    private sealed class ModuleTestArchitecture(Action<ModuleTestArchitecture> registrationAction) : Architecture
+    {
+        /// <summary>
+        ///     打开 Mediator 服务注册，以便测试中介行为接入。
+        /// </summary>
+        public override Action<IServiceCollection>? Configurator =>
+            services => services.AddMediator(options => { options.ServiceLifetime = ServiceLifetime.Singleton; });
+
+        /// <summary>
+        ///     在初始化阶段执行测试注入的模块注册逻辑。
+        /// </summary>
+        protected override void OnInitialize()
+        {
+            registrationAction(this);
+        }
+    }
+
+    /// <summary>
+    ///     记录模块安装调用情况的测试模块。
+    /// </summary>
+    private sealed class TrackingArchitectureModule : IArchitectureModule
+    {
+        /// <summary>
+        ///     获取模块安装调用次数。
+        /// </summary>
+        public int InstallCallCount { get; private set; }
+
+        /// <summary>
+        ///     获取最近一次接收到的架构实例。
+        /// </summary>
+        public IArchitecture? InstalledArchitecture { get; private set; }
+
+        /// <summary>
+        ///     记录安装调用，并在安装阶段注册一个工具验证调用链可用。
+        /// </summary>
+        /// <param name="architecture">目标架构实例。</param>
+        public void Install(IArchitecture architecture)
+        {
+            InstallCallCount++;
+            InstalledArchitecture = architecture;
+            architecture.RegisterUtility(new InstalledByModuleUtility());
+        }
+    }
+
+    /// <summary>
+    ///     由测试模块安装时注册的简单工具。
+    /// </summary>
+    private sealed class InstalledByModuleUtility : IUtility
+    {
+    }
+}
+
+/// <summary>
+///     用于验证管道行为注册是否生效的测试请求。
+/// </summary>
+public sealed class ModuleBehaviorRequest : IRequest<string>
+{
+}
+
+/// <summary>
+///     处理测试请求的处理器。
+/// </summary>
+public sealed class ModuleBehaviorRequestHandler : IRequestHandler<ModuleBehaviorRequest, string>
+{
+    /// <summary>
+    ///     返回固定结果，便于聚焦验证管道行为是否执行。
+    /// </summary>
+    /// <param name="request">请求实例。</param>
+    /// <param name="cancellationToken">取消令牌。</param>
+    /// <returns>固定响应内容。</returns>
+    public ValueTask<string> Handle(ModuleBehaviorRequest request, CancellationToken cancellationToken)
+    {
+        return ValueTask.FromResult("handled");
+    }
+}
+
+/// <summary>
+///     记录请求通过管道次数的测试行为。
+/// </summary>
+/// <typeparam name="TRequest">请求类型。</typeparam>
+/// <typeparam name="TResponse">响应类型。</typeparam>
+public sealed class TrackingPipelineBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : IRequest<TResponse>
+{
+    /// <summary>
+    ///     获取当前测试进程中该请求类型对应的行为触发次数。
+    /// </summary>
+    public static int InvocationCount { get; set; }
+
+    /// <summary>
+    ///     记录一次行为执行，然后继续执行下一个处理器。
+    /// </summary>
+    /// <param name="message">当前请求消息。</param>
+    /// <param name="next">下一个处理委托。</param>
+    /// <param name="cancellationToken">取消令牌。</param>
+    /// <returns>下游处理器的响应结果。</returns>
+    public async ValueTask<TResponse> Handle(
+        TRequest message,
+        MessageHandlerDelegate<TRequest, TResponse> next,
+        CancellationToken cancellationToken)
+    {
+        InvocationCount++;
+        return await next(message, cancellationToken);
+    }
+}

GFramework.Core/Architectures/Architecture.cs

@@ -16,6 +16,7 @@ namespace GFramework.Core.Architectures;
 ///     专注于生命周期管理、初始化流程控制和架构阶段转换。
 ///
 ///     重构说明：此类已重构为协调器模式，将职责委托给专门的管理器：
+///     - ArchitectureBootstrapper: 初始化基础设施编排
 ///     - ArchitectureLifecycle: 生命周期管理
 ///     - ArchitectureComponentRegistry: 组件注册管理
 ///     - ArchitectureModules: 模块管理
@@ -37,19 +38,25 @@ public abstract class Architecture : IArchitecture
         IArchitectureServices? services = null,
         IArchitectureContext? context = null)
     {
-        Configuration = configuration ?? new ArchitectureConfiguration();
+        var resolvedConfiguration = configuration ?? new ArchitectureConfiguration();
-        Environment = environment ?? new DefaultEnvironment();
+        var resolvedEnvironment = environment ?? new DefaultEnvironment();
-        Services = services ?? new ArchitectureServices();
+        var resolvedServices = services ?? new ArchitectureServices();
         _context = context;
 
         // 初始化 Logger
-        LoggerFactoryResolver.Provider = Configuration.LoggerProperties.LoggerFactoryProvider;
+        LoggerFactoryResolver.Provider = resolvedConfiguration.LoggerProperties.LoggerFactoryProvider;
         _logger = LoggerFactoryResolver.Provider.CreateLogger(GetType().Name);
 
         // 初始化管理器
-        _lifecycle = new ArchitectureLifecycle(this, Configuration, Services, _logger);
+        _bootstrapper = new ArchitectureBootstrapper(GetType(), resolvedEnvironment, resolvedServices, _logger);
-        _componentRegistry = new ArchitectureComponentRegistry(this, Configuration, Services, _lifecycle, _logger);
+        _lifecycle = new ArchitectureLifecycle(this, resolvedConfiguration, resolvedServices, _logger);
-        _modules = new ArchitectureModules(this, Services, _logger);
+        _componentRegistry = new ArchitectureComponentRegistry(
+            this,
+            resolvedConfiguration,
+            resolvedServices,
+            _lifecycle,
+            _logger);
+        _modules = new ArchitectureModules(this, resolvedServices, _logger);
     }
 
     #endregion
@@ -70,21 +77,6 @@ public abstract class Architecture : IArchitecture
 
     #region Properties
 
-    /// <summary>
-    ///     获取架构配置对象
-    /// </summary>
-    private IArchitectureConfiguration Configuration { get; }
-
-    /// <summary>
-    ///     获取环境配置对象
-    /// </summary>
-    private IEnvironment Environment { get; }
-
-    /// <summary>
-    ///     获取服务管理器
-    /// </summary>
-    private IArchitectureServices Services { get; }
-
     /// <summary>
     ///     当前架构的阶段
     /// </summary>
@@ -129,6 +121,11 @@ public abstract class Architecture : IArchitecture
     /// </summary>
     private IArchitectureContext? _context;
 
+    /// <summary>
+    ///     初始化基础设施编排器
+    /// </summary>
+    private readonly ArchitectureBootstrapper _bootstrapper;
+
     /// <summary>
     ///     生命周期管理器
     /// </summary>
@@ -150,7 +147,8 @@ public abstract class Architecture : IArchitecture
 
     /// <summary>
     ///     注册中介行为管道
-    ///     用于配置Mediator框架的行为拦截和处理逻辑
+    ///     用于配置Mediator框架的行为拦截和处理逻辑。
+    ///     可以传入开放泛型行为类型，也可以传入绑定到特定请求的封闭行为类型。
     /// </summary>
     /// <typeparam name="TBehavior">行为类型，必须是引用类型</typeparam>
     public void RegisterMediatorBehavior<TBehavior>() where TBehavior : class
@@ -184,7 +182,7 @@ public abstract class Architecture : IArchitecture
     }
 
     /// <summary>
-    ///     注册系统类型，由 DI 容器自动创建实例
+    ///     注册系统类型，由当前服务集合自动创建实例并接入本轮初始化
     /// </summary>
     /// <typeparam name="T">系统类型</typeparam>
     /// <param name="onCreated">可选的实例创建后回调</param>
@@ -205,7 +203,7 @@ public abstract class Architecture : IArchitecture
     }
 
     /// <summary>
-    ///     注册模型类型，由 DI 容器自动创建实例
+    ///     注册模型类型，由当前服务集合自动创建实例并接入本轮初始化
     /// </summary>
     /// <typeparam name="T">模型类型</typeparam>
     /// <param name="onCreated">可选的实例创建后回调</param>
@@ -284,32 +282,7 @@ public abstract class Architecture : IArchitecture
     /// <param name="asyncMode">是否启用异步模式</param>
     private async Task InitializeInternalAsync(bool asyncMode)
     {
-        // === 基础环境初始化 ===
+        _context = await _bootstrapper.PrepareForInitializationAsync(_context, Configurator, asyncMode);
-        Environment.Initialize();
-
-        // 注册内置服务模块
-        Services.ModuleManager.RegisterBuiltInModules(Services.Container);
-
-        // 将 Environment 注册到容器
-        if (!Services.Container.Contains<IEnvironment>())
-            Services.Container.RegisterPlurality(Environment);
-
-        // 初始化架构上下文
-        _context ??= new ArchitectureContext(Services.Container);
-        GameContext.Bind(GetType(), _context);
-
-        // 为服务设置上下文
-        Services.SetContext(_context);
-        if (Configurator is null)
-        {
-            _logger.Debug("Mediator-based cqrs will not take effect without the service setter configured!");
-        }
-
-        // 执行服务钩子
-        Services.Container.ExecuteServicesHook(Configurator);
-
-        // 初始化服务模块
-        await Services.ModuleManager.InitializeAllAsync(asyncMode);
 
         // === 用户 OnInitialize ===
         _logger.Debug("Calling user OnInitialize()");
@@ -320,9 +293,7 @@ public abstract class Architecture : IArchitecture
         await _lifecycle.InitializeAllComponentsAsync(asyncMode);
 
         // === 初始化完成阶段 ===
-        Services.Container.Freeze();
+        _bootstrapper.CompleteInitialization();
-        _logger.Info("IOC container frozen");
-
         _lifecycle.MarkAsReady();
         _logger.Info($"Architecture {GetType().Name} is ready - all components initialized");
     }

GFramework.Core/Architectures/ArchitectureBootstrapper.cs

@@ -0,0 +1,118 @@
+using GFramework.Core.Abstractions.Architectures;
+using GFramework.Core.Abstractions.Environment;
+using GFramework.Core.Abstractions.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GFramework.Core.Architectures;
+
+/// <summary>
+///     协调架构初始化期间的基础设施准备工作。
+///     该类型将环境初始化、服务模块启动、上下文绑定和服务容器配置从 <see cref="Architecture" /> 中拆出，
+///     使核心架构类只保留生命周期入口和公共 API 协调职责。
+/// </summary>
+internal sealed class ArchitectureBootstrapper(
+    Type architectureType,
+    IEnvironment environment,
+    IArchitectureServices services,
+    ILogger logger)
+{
+    /// <summary>
+    ///     在执行用户 <c>OnInitialize</c> 之前准备架构运行时。
+    ///     该流程必须保证环境、内置服务、上下文和服务钩子已经可用，
+    ///     因为用户初始化逻辑通常会立即访问事件总线、查询执行器或环境对象。
+    /// </summary>
+    /// <param name="existingContext">调用方已经提供的上下文；如果为空则创建默认上下文。</param>
+    /// <param name="configurator">可选的容器配置委托，用于接入 Mediator 等扩展服务。</param>
+    /// <param name="asyncMode">是否以异步模式初始化服务模块。</param>
+    /// <returns>已绑定到当前架构类型的架构上下文。</returns>
+    public async Task<IArchitectureContext> PrepareForInitializationAsync(
+        IArchitectureContext? existingContext,
+        Action<IServiceCollection>? configurator,
+        bool asyncMode)
+    {
+        InitializeEnvironment();
+        RegisterBuiltInModules();
+        EnsureEnvironmentRegistered();
+
+        var context = EnsureContext(existingContext);
+        ConfigureServices(context, configurator);
+        await InitializeServiceModulesAsync(asyncMode);
+        return context;
+    }
+
+    /// <summary>
+    ///     完成用户组件初始化之后的收尾工作。
+    ///     冻结容器可以阻止 Ready 阶段之后的意外服务注册，保持运行时依赖图稳定。
+    /// </summary>
+    public void CompleteInitialization()
+    {
+        services.Container.Freeze();
+        logger.Info("IOC container frozen");
+    }
+
+    /// <summary>
+    ///     初始化运行环境，使环境对象在后续服务构建和用户初始化前进入可用状态。
+    /// </summary>
+    private void InitializeEnvironment()
+    {
+        environment.Initialize();
+    }
+
+    /// <summary>
+    ///     注册框架内置服务模块。
+    ///     该步骤必须先于执行服务钩子，以便容器具备 CQRS 和事件总线等基础服务。
+    /// </summary>
+    private void RegisterBuiltInModules()
+    {
+        services.ModuleManager.RegisterBuiltInModules(services.Container);
+    }
+
+    /// <summary>
+    ///     确保环境对象可以通过架构容器解析。
+    ///     如果调用方已经预先注册了自定义环境实例，则保留现有绑定，避免覆盖外部配置。
+    /// </summary>
+    private void EnsureEnvironmentRegistered()
+    {
+        if (!services.Container.Contains<IEnvironment>())
+            services.Container.RegisterPlurality(environment);
+    }
+
+    /// <summary>
+    ///     获取本次初始化使用的架构上下文，并将其绑定到全局游戏上下文表。
+    ///     绑定发生在用户初始化之前，确保组件在注册阶段即可通过架构类型解析上下文。
+    /// </summary>
+    /// <param name="existingContext">外部提供的上下文。</param>
+    /// <returns>实际用于本次初始化的上下文实例。</returns>
+    private IArchitectureContext EnsureContext(IArchitectureContext? existingContext)
+    {
+        var context = existingContext ?? new ArchitectureContext(services.Container);
+        GameContext.Bind(architectureType, context);
+        return context;
+    }
+
+    /// <summary>
+    ///     为服务容器设置上下文并执行扩展配置钩子。
+    ///     这一步统一承接 Mediator 等容器扩展的接入点，避免 <see cref="Architecture" /> 直接操作容器细节。
+    /// </summary>
+    /// <param name="context">当前架构上下文。</param>
+    /// <param name="configurator">可选的服务集合配置委托。</param>
+    private void ConfigureServices(IArchitectureContext context, Action<IServiceCollection>? configurator)
+    {
+        services.SetContext(context);
+
+        if (configurator is null)
+            logger.Debug("Mediator-based cqrs will not take effect without the service setter configured!");
+
+        services.Container.ExecuteServicesHook(configurator);
+    }
+
+    /// <summary>
+    ///     初始化所有服务模块。
+    ///     该过程在用户注册系统、模型和工具之前完成，避免组件在初始化期间访问未准备好的服务。
+    /// </summary>
+    /// <param name="asyncMode">是否允许异步初始化服务模块。</param>
+    private async Task InitializeServiceModulesAsync(bool asyncMode)
+    {
+        await services.ModuleManager.InitializeAllAsync(asyncMode);
+    }
+}

GFramework.Core/Architectures/ArchitectureComponentActivator.cs

@@ -0,0 +1,106 @@
+using GFramework.Core.Abstractions.Ioc;
+using GFramework.Core.Abstractions.Logging;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace GFramework.Core.Architectures;
+
+/// <summary>
+///     为架构组件的类型注册路径提供实例创建能力。
+///     该类型在容器冻结前基于当前服务集合和已注册实例进行激活，
+///     使 <see cref="ArchitectureComponentRegistry" /> 可以在注册阶段就物化 System / Model，
+///     避免它们在 Ready 之后首次解析时才参与生命周期而导致状态不一致。
+/// </summary>
+internal sealed class ArchitectureComponentActivator(
+    IIocContainer container,
+    ILogger logger)
+{
+    /// <summary>
+    ///     预冻结阶段的单例实例缓存。
+    ///     该缓存跨越整个架构组件激活周期共享，确保多个组件在同一轮初始化中解析到同一个单例描述时不会重复创建实例。
+    /// </summary>
+    private readonly Dictionary<Type, object?> _singletonCache = [];
+
+    /// <summary>
+    ///     根据当前容器状态创建组件实例。
+    ///     激活过程优先复用已经注册到容器中的实例，再按服务描述解析实现类型或工厂方法，
+    ///     以兼容构造函数依赖于框架服务、用户实例服务和先前注册组件的场景。
+    /// </summary>
+    /// <typeparam name="TComponent">要创建的组件类型。</typeparam>
+    /// <returns>创建完成的组件实例。</returns>
+    public TComponent CreateInstance<TComponent>() where TComponent : class
+    {
+        var activationProvider = new RegistrationServiceProvider(container, logger, _singletonCache);
+        return ActivatorUtilities.CreateInstance<TComponent>(activationProvider);
+    }
+
+    /// <summary>
+    ///     面向组件注册的轻量级服务提供者。
+    ///     该实现只覆盖预冻结阶段需要的解析能力，避免引入完整容器冻结过程。
+    /// </summary>
+    private sealed class RegistrationServiceProvider(
+        IIocContainer container,
+        ILogger logger,
+        Dictionary<Type, object?> singletonCache) : IServiceProvider
+    {
+        /// <summary>
+        ///     共享的单例缓存。
+        ///     该缓存由外层 activator 统一持有，从而把单例复用范围提升到整个组件注册批次，而不是单次实例创建调用。
+        /// </summary>
+        private readonly Dictionary<Type, object?> _singletonCache = singletonCache;
+
+        /// <summary>
+        ///     从当前服务集合中解析指定类型的服务。
+        ///     解析顺序为：已注册实例 → 服务描述实例/工厂/实现类型 → 可直接实例化的具体类型。
+        /// </summary>
+        /// <param name="serviceType">请求解析的服务类型。</param>
+        /// <returns>解析到的服务实例；若无法解析则返回 null。</returns>
+        public object? GetService(Type serviceType)
+        {
+            if (serviceType == typeof(IServiceProvider))
+                return this;
+
+            var existingInstance = container.Get(serviceType);
+            if (existingInstance != null)
+                return existingInstance;
+
+            var descriptor =
+                container.GetServicesUnsafe.LastOrDefault(candidate => candidate.ServiceType == serviceType);
+            if (descriptor != null)
+                return ResolveDescriptor(serviceType, descriptor);
+
+            if (!serviceType.IsAbstract && !serviceType.IsInterface)
+                return ActivatorUtilities.CreateInstance(this, serviceType);
+
+            logger.Trace($"Activation provider could not resolve {serviceType.Name}");
+            return null;
+        }
+
+        /// <summary>
+        ///     根据服务描述解析实例，并对单例描述进行缓存。
+        ///     这样可以保证同一类型在一次组件注册流程中只创建一次依赖实例。
+        /// </summary>
+        /// <param name="requestedType">请求的服务类型。</param>
+        /// <param name="descriptor">命中的服务描述。</param>
+        /// <returns>解析到的实例。</returns>
+        private object? ResolveDescriptor(Type requestedType, ServiceDescriptor descriptor)
+        {
+            if (descriptor.Lifetime == ServiceLifetime.Singleton &&
+                _singletonCache.TryGetValue(requestedType, out var cached))
+                return cached;
+
+            object? resolved = descriptor switch
+            {
+                { ImplementationInstance: not null } => descriptor.ImplementationInstance,
+                { ImplementationFactory: not null } => descriptor.ImplementationFactory(this),
+                { ImplementationType: not null } => ActivatorUtilities.CreateInstance(this,
+                    descriptor.ImplementationType),
+                _ => null
+            };
+
+            if (descriptor.Lifetime == ServiceLifetime.Singleton && resolved != null)
+                _singletonCache[requestedType] = resolved;
+
+            return resolved;
+        }
+    }
+}

GFramework.Core/Architectures/ArchitectureComponentRegistry.cs

@@ -20,6 +20,8 @@ internal sealed class ArchitectureComponentRegistry(
     ArchitectureLifecycle lifecycle,
     ILogger logger)
 {
+    private readonly ArchitectureComponentActivator _activator = new(services.Container, logger);
+
     #region Validation
 
     /// <summary>
@@ -63,7 +65,8 @@ internal sealed class ArchitectureComponentRegistry(
     }
 
     /// <summary>
-    ///     注册系统类型，由 DI 容器自动创建实例
+    ///     注册系统类型，并在注册阶段由当前服务集合立即创建实例。
+    ///     这样可以确保该系统参与当前架构初始化批次，而不是等到 Ready 之后首次解析时才延迟创建。
     /// </summary>
     /// <typeparam name="T">系统类型</typeparam>
     /// <param name="onCreated">可选的实例创建后回调</param>
@@ -72,21 +75,12 @@ internal sealed class ArchitectureComponentRegistry(
         ValidateRegistration("system");
         logger.Debug($"Registering system type: {typeof(T).Name}");
 
-        services.Container.RegisterFactory<T>(sp =>
+        // 类型注册路径在注册阶段就物化实例，确保组件能参与当前初始化批次。
-        {
+        var system = _activator.CreateInstance<T>();
-            // 1. DI 创建实例
+        system.SetContext(architecture.Context);
-            var system = ActivatorUtilities.CreateInstance<T>(sp);
+        lifecycle.RegisterLifecycleComponent(system);
-
+        onCreated?.Invoke(system);
-            // 2. 框架默认处理
+        services.Container.RegisterPlurality(system);
-            system.SetContext(architecture.Context);
-            lifecycle.RegisterLifecycleComponent(system);
-
-            // 3. 用户自定义处理（钩子）
-            onCreated?.Invoke(system);
-
-            logger.Debug($"System created: {typeof(T).Name}");
-            return system;
-        });
 
         logger.Info($"System type registered: {typeof(T).Name}");
     }
@@ -118,7 +112,8 @@ internal sealed class ArchitectureComponentRegistry(
     }
 
     /// <summary>
-    ///     注册模型类型，由 DI 容器自动创建实例
+    ///     注册模型类型，并在注册阶段由当前服务集合立即创建实例。
+    ///     这样可以确保该模型参与当前架构初始化批次，而不是等到 Ready 之后首次解析时才延迟创建。
     /// </summary>
     /// <typeparam name="T">模型类型</typeparam>
     /// <param name="onCreated">可选的实例创建后回调</param>
@@ -127,18 +122,11 @@ internal sealed class ArchitectureComponentRegistry(
         ValidateRegistration("model");
         logger.Debug($"Registering model type: {typeof(T).Name}");
 
-        services.Container.RegisterFactory<T>(sp =>
+        var model = _activator.CreateInstance<T>();
-        {
+        model.SetContext(architecture.Context);
-            var model = ActivatorUtilities.CreateInstance<T>(sp);
+        lifecycle.RegisterLifecycleComponent(model);
-            model.SetContext(architecture.Context);
+        onCreated?.Invoke(model);
-            lifecycle.RegisterLifecycleComponent(model);
+        services.Container.RegisterPlurality(model);
-
-            // 用户自定义钩子
-            onCreated?.Invoke(model);
-
-            logger.Debug($"Model created: {typeof(T).Name}");
-            return model;
-        });
 
         logger.Info($"Model type registered: {typeof(T).Name}");
     }
@@ -155,6 +143,7 @@ internal sealed class ArchitectureComponentRegistry(
     /// <returns>注册成功的工具实例</returns>
     public TUtility RegisterUtility<TUtility>(TUtility utility) where TUtility : IUtility
     {
+        ValidateRegistration("utility");
         logger.Debug($"Registering utility: {typeof(TUtility).Name}");
 
         // 处理上下文工具类型的设置和生命周期管理
@@ -177,6 +166,7 @@ internal sealed class ArchitectureComponentRegistry(
     /// <param name="onCreated">可选的实例创建后回调</param>
     public void RegisterUtility<T>(Action<T>? onCreated = null) where T : class, IUtility
     {
+        ValidateRegistration("utility");
         logger.Debug($"Registering utility type: {typeof(T).Name}");
 
         services.Container.RegisterFactory<T>(sp =>

GFramework.Core/Architectures/ArchitectureDisposer.cs

@@ -0,0 +1,112 @@
+using GFramework.Core.Abstractions.Architectures;
+using GFramework.Core.Abstractions.Enums;
+using GFramework.Core.Abstractions.Lifecycle;
+using GFramework.Core.Abstractions.Logging;
+
+namespace GFramework.Core.Architectures;
+
+/// <summary>
+///     统一处理架构内可销毁对象的登记与释放。
+///     该类型封装逆序销毁、异常隔离和服务模块清理规则，
+///     让 <see cref="ArchitectureLifecycle" /> 可以专注于初始化流程本身。
+/// </summary>
+internal sealed class ArchitectureDisposer(
+    IArchitectureServices services,
+    ILogger logger)
+{
+    /// <summary>
+    ///     保留注册顺序的可销毁对象列表。
+    ///     销毁时按逆序遍历，以尽量匹配组件间的依赖方向。
+    /// </summary>
+    private readonly List<object> _disposables = [];
+
+    /// <summary>
+    ///     用于去重的可销毁对象集合。
+    /// </summary>
+    private readonly HashSet<object> _disposableSet = [];
+
+    /// <summary>
+    ///     注册一个需要参与架构销毁流程的对象。
+    ///     只有实现 <see cref="IDestroyable" /> 或 <see cref="IAsyncDestroyable" /> 的对象会被跟踪。
+    /// </summary>
+    /// <param name="component">待检查的组件实例。</param>
+    public void Register(object component)
+    {
+        if (component is not (IDestroyable or IAsyncDestroyable))
+            return;
+
+        if (!_disposableSet.Add(component))
+            return;
+
+        _disposables.Add(component);
+        logger.Trace($"Registered {component.GetType().Name} for destruction");
+    }
+
+    /// <summary>
+    ///     执行架构销毁流程。
+    ///     该方法会根据当前阶段决定是否进入 Destroying/Destroyed 阶段，并负责服务模块与容器清理。
+    /// </summary>
+    /// <param name="currentPhase">销毁开始前的架构阶段。</param>
+    /// <param name="enterPhase">用于推进架构阶段的回调。</param>
+    public async ValueTask DestroyAsync(ArchitecturePhase currentPhase, Action<ArchitecturePhase> enterPhase)
+    {
+        if (currentPhase is ArchitecturePhase.Destroying or ArchitecturePhase.Destroyed)
+        {
+            logger.Warn("Architecture destroy called but already in destroying/destroyed state");
+            return;
+        }
+
+        if (currentPhase == ArchitecturePhase.None)
+        {
+            logger.Debug("Architecture destroy called but never initialized, cleaning up registered components");
+            await CleanupComponentsAsync();
+            return;
+        }
+
+        logger.Info("Starting architecture destruction");
+        enterPhase(ArchitecturePhase.Destroying);
+
+        await CleanupComponentsAsync();
+        await services.ModuleManager.DestroyAllAsync();
+
+        // Destroyed 广播依赖容器中的阶段监听器，必须在清空容器前完成。
+        enterPhase(ArchitecturePhase.Destroyed);
+        services.Container.Clear();
+        logger.Info("Architecture destruction completed");
+    }
+
+    /// <summary>
+    ///     逆序销毁当前已注册的所有可销毁组件。
+    ///     单个组件失败不会中断后续清理，避免在销毁阶段留下半清理状态。
+    /// </summary>
+    private async ValueTask CleanupComponentsAsync()
+    {
+        logger.Info($"Destroying {_disposables.Count} disposable components");
+
+        for (var i = _disposables.Count - 1; i >= 0; i--)
+        {
+            var component = _disposables[i];
+
+            try
+            {
+                logger.Debug($"Destroying component: {component.GetType().Name}");
+
+                if (component is IAsyncDestroyable asyncDestroyable)
+                {
+                    await asyncDestroyable.DestroyAsync();
+                }
+                else if (component is IDestroyable destroyable)
+                {
+                    destroyable.Destroy();
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.Error($"Error destroying {component.GetType().Name}", ex);
+            }
+        }
+
+        _disposables.Clear();
+        _disposableSet.Clear();
+    }
+}

GFramework.Core/Architectures/ArchitectureLifecycle.cs

@@ -27,11 +27,7 @@ internal sealed class ArchitectureLifecycle(
     /// <returns>注册的钩子实例</returns>
     public IArchitectureLifecycleHook RegisterLifecycleHook(IArchitectureLifecycleHook hook)
     {
-        if (CurrentPhase >= ArchitecturePhase.Ready && !configuration.ArchitectureProperties.AllowLateRegistration)
+        return _phaseCoordinator.RegisterLifecycleHook(hook);
-            throw new InvalidOperationException(
-                "Cannot register lifecycle hook after architecture is Ready");
-        _lifecycleHooks.Add(hook);
-        return hook;
     }
 
     #endregion
@@ -44,31 +40,37 @@ internal sealed class ArchitectureLifecycle(
     /// <param name="component">要注册的组件</param>
     public void RegisterLifecycleComponent(object component)
     {
-        // 处理初始化
         if (component is IInitializable initializable)
         {
-            if (!_initialized)
+            if (_initialized)
             {
-                // 原子去重：HashSet.Add 返回 true 表示添加成功（之前不存在）
+                if (!configuration.ArchitectureProperties.AllowLateRegistration)
-                if (_pendingInitializableSet.Add(initializable))
+                    throw new InvalidOperationException("Cannot initialize component after Architecture is Ready");
-                {
+
-                    _pendingInitializableList.Add(initializable);
+                InitializeLateRegisteredComponent(initializable);
-                    logger.Trace($"Added {component.GetType().Name} to pending initialization queue");
-                }
             }
-            else
+
+            else if (_pendingInitializableSet.Add(initializable))
             {
-                throw new InvalidOperationException(
+                _pendingInitializableList.Add(initializable);
-                    "Cannot initialize component after Architecture is Ready");
+                logger.Trace($"Added {component.GetType().Name} to pending initialization queue");
             }
         }
 
-        // 处理销毁（支持 IDestroyable 或 IAsyncDestroyable）
+        _disposer.Register(component);
-        if (component is not (IDestroyable or IAsyncDestroyable)) return;
+    }
-        // 原子去重：HashSet.Add 返回 true 表示添加成功（之前不存在）
+
-        if (!_disposableSet.Add(component)) return;
+    #endregion
-        _disposables.Add(component);
+
-        logger.Trace($"Registered {component.GetType().Name} for destruction");
+    #region Phase Management
+
+    /// <summary>
+    ///     进入指定的架构阶段，并执行相应的生命周期管理操作
+    /// </summary>
+    /// <param name="next">要进入的下一个架构阶段</param>
+    public void EnterPhase(ArchitecturePhase next)
+    {
+        _phaseCoordinator.EnterPhase(next);
     }
 
     #endregion
@@ -88,19 +90,15 @@ internal sealed class ArchitectureLifecycle(
     private readonly List<IInitializable> _pendingInitializableList = [];
 
     /// <summary>
-    ///     可销毁组件的去重集合（支持 IDestroyable 和 IAsyncDestroyable）
+    ///     架构阶段协调器
     /// </summary>
-    private readonly HashSet<object> _disposableSet = [];
+    private readonly ArchitecturePhaseCoordinator _phaseCoordinator =
+        new(architecture, configuration, services, logger);
 
     /// <summary>
-    ///     存储所有需要销毁的组件（统一管理，保持注册逆序销毁）
+    ///     架构销毁协调器
     /// </summary>
-    private readonly List<object> _disposables = [];
+    private readonly ArchitectureDisposer _disposer = new(services, logger);
-
-    /// <summary>
-    ///     生命周期感知对象列表
-    /// </summary>
-    private readonly List<IArchitectureLifecycleHook> _lifecycleHooks = [];
 
     /// <summary>
     ///     标记架构是否已初始化完成
@@ -114,7 +112,7 @@ internal sealed class ArchitectureLifecycle(
     /// <summary>
     ///     当前架构的阶段
     /// </summary>
-    public ArchitecturePhase CurrentPhase { get; private set; }
+    public ArchitecturePhase CurrentPhase => _phaseCoordinator.CurrentPhase;
 
     /// <summary>
     ///     获取一个布尔值，指示当前架构是否处于就绪状态
@@ -129,87 +127,10 @@ internal sealed class ArchitectureLifecycle(
     /// <summary>
     ///     阶段变更事件（用于测试和扩展）
     /// </summary>
-    public event Action<ArchitecturePhase>? PhaseChanged;
+    public event Action<ArchitecturePhase>? PhaseChanged
-
-    #endregion
-
-    #region Phase Management
-
-    /// <summary>
-    ///     进入指定的架构阶段，并执行相应的生命周期管理操作
-    /// </summary>
-    /// <param name="next">要进入的下一个架构阶段</param>
-    /// <exception cref="InvalidOperationException">当阶段转换不被允许时抛出异常</exception>
-    public void EnterPhase(ArchitecturePhase next)
     {
-        // 验证阶段转换
+        add => _phaseCoordinator.PhaseChanged += value;
-        ValidatePhaseTransition(next);
+        remove => _phaseCoordinator.PhaseChanged -= value;
-
-        // 执行阶段转换
-        var previousPhase = CurrentPhase;
-        CurrentPhase = next;
-
-        if (previousPhase != next)
-            logger.Info($"Architecture phase changed: {previousPhase} -> {next}");
-
-        // 通知阶段变更
-        NotifyPhase(next);
-        NotifyPhaseAwareObjects(next);
-
-        // 触发阶段变更事件（用于测试和扩展）
-        PhaseChanged?.Invoke(next);
-    }
-
-    /// <summary>
-    ///     验证阶段转换是否合法
-    /// </summary>
-    /// <param name="next">目标阶段</param>
-    /// <exception cref="InvalidOperationException">当阶段转换不合法时抛出</exception>
-    private void ValidatePhaseTransition(ArchitecturePhase next)
-    {
-        // 不需要严格验证，直接返回
-        if (!configuration.ArchitectureProperties.StrictPhaseValidation)
-            return;
-
-        // FailedInitialization 可以从任何阶段转换，直接返回
-        if (next == ArchitecturePhase.FailedInitialization)
-            return;
-
-        // 检查转换是否在允许列表中
-        if (ArchitectureConstants.PhaseTransitions.TryGetValue(CurrentPhase, out var allowed) &&
-            allowed.Contains(next))
-            return;
-
-        // 转换不合法，抛出异常
-        var errorMsg = $"Invalid phase transition: {CurrentPhase} -> {next}";
-        logger.Fatal(errorMsg);
-        throw new InvalidOperationException(errorMsg);
-    }
-
-    /// <summary>
-    ///     通知所有架构阶段感知对象阶段变更
-    /// </summary>
-    /// <param name="phase">新阶段</param>
-    private void NotifyPhaseAwareObjects(ArchitecturePhase phase)
-    {
-        foreach (var obj in services.Container.GetAll<IArchitecturePhaseListener>())
-        {
-            logger.Trace($"Notifying phase-aware object {obj.GetType().Name} of phase change to {phase}");
-            obj.OnArchitecturePhase(phase);
-        }
-    }
-
-    /// <summary>
-    ///     通知所有生命周期钩子当前阶段变更
-    /// </summary>
-    /// <param name="phase">当前架构阶段</param>
-    private void NotifyPhase(ArchitecturePhase phase)
-    {
-        foreach (var hook in _lifecycleHooks)
-        {
-            hook.OnPhase(phase, architecture);
-            logger.Trace($"Notifying lifecycle hook {hook.GetType().Name} of phase {phase}");
-        }
     }
 
     #endregion
@@ -302,6 +223,18 @@ internal sealed class ArchitectureLifecycle(
             component.Initialize();
     }
 
+    /// <summary>
+    ///     立即初始化在常规初始化批次完成后新增的组件。
+    ///     当启用 <c>AllowLateRegistration</c> 时，生命周期层需要和注册层保持一致，
+    ///     让新增组件在注册当下完成同步初始化，而不是停留在未初始化状态。
+    /// </summary>
+    /// <param name="component">后注册的可初始化组件。</param>
+    private void InitializeLateRegisteredComponent(IInitializable component)
+    {
+        logger.Debug($"Initializing late-registered component: {component.GetType().Name}");
+        component.Initialize();
+    }
+
     #endregion
 
     #region Destruction
@@ -311,72 +244,7 @@ internal sealed class ArchitectureLifecycle(
     /// </summary>
     public async ValueTask DestroyAsync()
     {
-        // 检查当前阶段，如果已经处于销毁或已销毁状态则直接返回
+        await _disposer.DestroyAsync(CurrentPhase, EnterPhase);
-        if (CurrentPhase >= ArchitecturePhase.Destroying)
-        {
-            logger.Warn("Architecture destroy called but already in destroying/destroyed state");
-            return;
-        }
-
-        // 如果从未初始化（None 阶段），只清理已注册的组件，不进行阶段转换
-        if (CurrentPhase == ArchitecturePhase.None)
-        {
-            logger.Debug("Architecture destroy called but never initialized, cleaning up registered components");
-            await CleanupComponentsAsync();
-            return;
-        }
-
-        // 进入销毁阶段
-        logger.Info("Starting architecture destruction");
-        EnterPhase(ArchitecturePhase.Destroying);
-
-        // 清理所有组件
-        await CleanupComponentsAsync();
-
-        // 销毁服务模块
-        await services.ModuleManager.DestroyAllAsync();
-
-        services.Container.Clear();
-
-        // 进入已销毁阶段
-        EnterPhase(ArchitecturePhase.Destroyed);
-        logger.Info("Architecture destruction completed");
-    }
-
-    /// <summary>
-    ///     清理所有已注册的可销毁组件
-    /// </summary>
-    private async ValueTask CleanupComponentsAsync()
-    {
-        // 销毁所有实现了 IAsyncDestroyable 或 IDestroyable 的组件（按注册逆序销毁）
-        logger.Info($"Destroying {_disposables.Count} disposable components");
-
-        for (var i = _disposables.Count - 1; i >= 0; i--)
-        {
-            var component = _disposables[i];
-            try
-            {
-                logger.Debug($"Destroying component: {component.GetType().Name}");
-
-                // 优先使用异步销毁
-                if (component is IAsyncDestroyable asyncDestroyable)
-                {
-                    await asyncDestroyable.DestroyAsync();
-                }
-                else if (component is IDestroyable destroyable)
-                {
-                    destroyable.Destroy();
-                }
-            }
-            catch (Exception ex)
-            {
-                logger.Error($"Error destroying {component.GetType().Name}", ex);
-                // 继续销毁其他组件，不会因为一个组件失败而中断
-            }
-        }
-
-        _disposables.Clear();
-        _disposableSet.Clear();
     }
 
     /// <summary>

GFramework.Core/Architectures/ArchitectureModules.cs

@@ -14,7 +14,8 @@ internal sealed class ArchitectureModules(
 {
     /// <summary>
     ///     注册中介行为管道
-    ///     用于配置Mediator框架的行为拦截和处理逻辑
+    ///     用于配置Mediator框架的行为拦截和处理逻辑。
+    ///     支持开放泛型行为类型和针对单一请求的封闭行为类型。
     /// </summary>
     /// <typeparam name="TBehavior">行为类型，必须是引用类型</typeparam>
     public void RegisterMediatorBehavior<TBehavior>() where TBehavior : class

GFramework.Core/Architectures/ArchitecturePhaseCoordinator.cs

@@ -0,0 +1,116 @@
+using GFramework.Core.Abstractions.Architectures;
+using GFramework.Core.Abstractions.Enums;
+using GFramework.Core.Abstractions.Logging;
+
+namespace GFramework.Core.Architectures;
+
+/// <summary>
+///     负责架构阶段流转的验证与通知。
+///     该类型集中管理阶段值、生命周期钩子和阶段监听器，避免 <see cref="ArchitectureLifecycle" />
+///     同时承担阶段广播与组件初始化队列管理两类职责。
+/// </summary>
+internal sealed class ArchitecturePhaseCoordinator(
+    IArchitecture architecture,
+    IArchitectureConfiguration configuration,
+    IArchitectureServices services,
+    ILogger logger)
+{
+    private readonly List<IArchitectureLifecycleHook> _lifecycleHooks = [];
+
+    /// <summary>
+    ///     获取当前架构阶段。
+    /// </summary>
+    public ArchitecturePhase CurrentPhase { get; private set; }
+
+    /// <summary>
+    ///     在架构阶段变更时触发。
+    ///     该事件用于测试和扩展场景，保持现有公共行为不变。
+    /// </summary>
+    public event Action<ArchitecturePhase>? PhaseChanged;
+
+    /// <summary>
+    ///     注册一个生命周期钩子。
+    ///     就绪后是否允许追加注册由架构配置控制，以保证阶段回调的一致性。
+    /// </summary>
+    /// <param name="hook">要注册的生命周期钩子。</param>
+    /// <returns>原样返回注册的钩子实例，便于链式调用或测试断言。</returns>
+    public IArchitectureLifecycleHook RegisterLifecycleHook(IArchitectureLifecycleHook hook)
+    {
+        if (CurrentPhase >= ArchitecturePhase.Ready && !configuration.ArchitectureProperties.AllowLateRegistration)
+            throw new InvalidOperationException("Cannot register lifecycle hook after architecture is Ready");
+
+        _lifecycleHooks.Add(hook);
+        return hook;
+    }
+
+    /// <summary>
+    ///     进入指定阶段并广播给所有阶段消费者。
+    ///     顺序保持为“更新阶段值 → 生命周期钩子 → 容器中的阶段监听器 → 外部事件”，
+    ///     以兼容既有调用约定。
+    /// </summary>
+    /// <param name="next">目标阶段。</param>
+    public void EnterPhase(ArchitecturePhase next)
+    {
+        ValidatePhaseTransition(next);
+
+        var previousPhase = CurrentPhase;
+        CurrentPhase = next;
+
+        if (previousPhase != next)
+            logger.Info($"Architecture phase changed: {previousPhase} -> {next}");
+
+        NotifyLifecycleHooks(next);
+        NotifyPhaseListeners(next);
+        PhaseChanged?.Invoke(next);
+    }
+
+    /// <summary>
+    ///     根据配置验证阶段迁移是否合法。
+    ///     在关闭严格校验时直接放行，以兼容对阶段流转有特殊需求的宿主。
+    /// </summary>
+    /// <param name="next">目标阶段。</param>
+    /// <exception cref="InvalidOperationException">当迁移不在允许集合中时抛出。</exception>
+    private void ValidatePhaseTransition(ArchitecturePhase next)
+    {
+        if (!configuration.ArchitectureProperties.StrictPhaseValidation)
+            return;
+
+        if (next == ArchitecturePhase.FailedInitialization)
+            return;
+
+        if (ArchitectureConstants.PhaseTransitions.TryGetValue(CurrentPhase, out var allowed) && allowed.Contains(next))
+            return;
+
+        var errorMessage = $"Invalid phase transition: {CurrentPhase} -> {next}";
+        logger.Fatal(errorMessage);
+        throw new InvalidOperationException(errorMessage);
+    }
+
+    /// <summary>
+    ///     通知所有生命周期钩子当前阶段已变更。
+    ///     生命周期钩子通常承载注册表装配等框架扩展逻辑，因此优先于普通阶段监听器执行。
+    /// </summary>
+    /// <param name="phase">当前阶段。</param>
+    private void NotifyLifecycleHooks(ArchitecturePhase phase)
+    {
+        foreach (var hook in _lifecycleHooks)
+        {
+            hook.OnPhase(phase, architecture);
+            logger.Trace($"Notifying lifecycle hook {hook.GetType().Name} of phase {phase}");
+        }
+    }
+
+    /// <summary>
+    ///     通知容器中的阶段监听器当前阶段已变更。
+    ///     这些对象通常是系统、模型或工具本身，依赖容器解析保证通知范围与运行时实例一致。
+    /// </summary>
+    /// <param name="phase">当前阶段。</param>
+    private void NotifyPhaseListeners(ArchitecturePhase phase)
+    {
+        foreach (var listener in services.Container.GetAll<IArchitecturePhaseListener>())
+        {
+            logger.Trace($"Notifying phase-aware object {listener.GetType().Name} of phase change to {phase}");
+            listener.OnArchitecturePhase(phase);
+        }
+    }
+}

GFramework.Core/Ioc/MicrosoftDiContainer.cs

@@ -311,7 +311,9 @@ public class MicrosoftDiContainer(IServiceCollection? serviceCollection = null)
 
     /// <summary>
     ///     注册中介行为管道
-    ///     用于配置Mediator框架的行为拦截和处理逻辑
+    ///     用于配置Mediator框架的行为拦截和处理逻辑。
+    ///     同时支持开放泛型行为类型和已闭合的具体行为类型，
+    ///     以兼容通用行为和针对单一请求的专用行为两种注册方式。
     /// </summary>
     /// <typeparam name="TBehavior">行为类型，必须是引用类型</typeparam>
     public void RegisterMediatorBehavior<TBehavior>() where TBehavior : class
@@ -321,12 +323,35 @@ public class MicrosoftDiContainer(IServiceCollection? serviceCollection = null)
         {
             ThrowIfFrozen();
 
-            GetServicesUnsafe.AddSingleton(
+            var behaviorType = typeof(TBehavior);
-                typeof(IPipelineBehavior<,>),
-                typeof(TBehavior)
-            );
 
-            _logger.Debug($"Mediator behavior registered: {typeof(TBehavior).Name}");
+            if (behaviorType.IsGenericTypeDefinition)
+            {
+                GetServicesUnsafe.AddSingleton(typeof(IPipelineBehavior<,>), behaviorType);
+            }
+            else
+            {
+                var pipelineInterfaces = behaviorType
+                    .GetInterfaces()
+                    .Where(type => type.IsGenericType &&
+                                   type.GetGenericTypeDefinition() == typeof(IPipelineBehavior<,>))
+                    .ToList();
+
+                if (pipelineInterfaces.Count == 0)
+                {
+                    var errorMessage = $"{behaviorType.Name} does not implement IPipelineBehavior<,>";
+                    _logger.Error(errorMessage);
+                    throw new InvalidOperationException(errorMessage);
+                }
+
+                // 为每个已闭合的管道接口建立显式映射，支持针对特定请求/响应的专用行为。
+                foreach (var pipelineInterface in pipelineInterfaces)
+                {
+                    GetServicesUnsafe.AddSingleton(pipelineInterface, behaviorType);
+                }
+            }
+
+            _logger.Debug($"Mediator behavior registered: {behaviorType.Name}");
         }
         finally
         {

docs/zh-CN/core/architecture.md

@@ -14,8 +14,13 @@
 
 ## 概述
 
-Architecture 是 GFramework 的核心类,负责管理整个应用的生命周期、组件注册和模块管理。从 v1.1.0 开始,Architecture
+Architecture 是 GFramework 的核心类,负责管理整个应用的生命周期、组件注册和模块管理。从 v1.1.0 开始,Architecture
-采用模块化设计,将职责分离到专门的管理器中。
+采用模块化设计,将职责分离到专门的协作者中。
+
+> 命名约定:
+> - `ArchitectureServices` 是公开的基础服务入口,负责容器、事件总线、命令执行器、查询执行器和服务模块管理
+> - `ArchitectureComponentRegistry` 是内部组件注册器,专门负责 System / Model / Utility 的注册与生命周期接入
+> - 两者不是同一层职责,不要混用
 
 ### 设计目标
 
@@ -28,10 +33,11 @@ Architecture 是 GFramework 的核心类,负责管理整个应用的生命周期
 ### 核心组件
 
 ```
-Architecture (核心协调器)
+Architecture (核心协调器)
-    ├── ArchitectureLifecycle (生命周期管理)
+    ├── ArchitectureBootstrapper (初始化基础设施编排)
-    ├── ArchitectureComponentRegistry (组件注册)
+    ├── ArchitectureLifecycle (生命周期管理)
-    └── ArchitectureModules (模块管理)
+    ├── ArchitectureComponentRegistry (组件注册)
+    └── ArchitectureModules (模块管理)
 ```
 
 ## 架构设计
@@ -40,18 +46,19 @@ Architecture (核心协调器)
 
 Architecture 采用以下设计模式:
 
-1. **组合模式 (Composition)**: Architecture 组合三个管理器
+1. **组合模式 (Composition)**: Architecture 组合多个内部协作者
-2. **委托模式 (Delegation)**: 方法调用委托给专门的管理器
+2. **委托模式 (Delegation)**: 方法调用委托给专门的管理器
-3. **协调器模式 (Coordinator)**: Architecture 作为协调器统一对外接口
+3. **协调器模式 (Coordinator)**: Architecture 作为协调器统一对外接口
 
 ### 类图
 
 ```
 ┌─────────────────────────────────────────────────────┐
-│                   Architecture                       │
+│                   Architecture                       │
-│  - _lifecycle: ArchitectureLifecycle                │
+│  - _bootstrapper: ArchitectureBootstrapper          │
-│  - _componentRegistry: ArchitectureComponentRegistry│
+│  - _lifecycle: ArchitectureLifecycle                │
-│  - _modules: ArchitectureModules                    │
+│  - _componentRegistry: ArchitectureComponentRegistry│
+│  - _modules: ArchitectureModules                    │
 │  - _logger: ILogger                                 │
 │                                                     │
 │  + RegisterSystem<T>()                              │
@@ -62,17 +69,17 @@ Architecture 采用以下设计模式:
 │  + DestroyAsync()                                   │
 │  + event PhaseChanged                               │
 └─────────────────────────────────────────────────────┘
-         │                    │                    │
+         │                    │                    │                    │
-         │                    │                    │
+         │                    │                    │                    │
-         ▼                    ▼                    ▼
+         ▼                    ▼                    ▼                    ▼
-┌──────────────┐   ┌──────────────────┐   ┌──────────────┐
+┌──────────────┐   ┌──────────────────┐   ┌──────────────┐   ┌──────────────┐
-│ Lifecycle    │   │ ComponentRegistry│   │   Modules    │
+│ Bootstrapper │   │ Lifecycle        │   │ComponentReg. │   │   Modules    │
-│              │   │                  │   │              │
+│              │   │                  │   │              │   │              │
-│ - 阶段管理    │   │ - System 注册    │   │ - 模块安装    │
+│ - 环境初始化  │   │ - 阶段管理        │   │ - System 注册│   │ - 模块安装    │
-│ - 钩子管理    │   │ - Model 注册     │   │ - 行为注册    │
+│ - 服务准备    │   │ - 钩子管理        │   │ - Model 注册 │   │ - 行为注册    │
-│ - 初始化      │   │ - Utility 注册   │   │              │
+│ - 上下文绑定  │   │ - 组件初始化      │   │ - Utility 注册│   │              │
-│ - 销毁        │   │ - 生命周期注册   │   │              │
+│ - 容器冻结    │   │ - 就绪/销毁协调   │   │ - 生命周期接入│   │              │
-└──────────────┘   └──────────────────┘   └──────────────┘
+└──────────────┘   └──────────────────┘   └──────────────┘   └──────────────┘
 ```
 
 ### 构造函数初始化
@@ -80,27 +87,28 @@ Architecture 采用以下设计模式:
 从 v1.1.0 开始,所有管理器在构造函数中初始化:
 
 ```csharp
-protected Architecture(
+protected Architecture(
-    IArchitectureConfiguration? configuration = null,
+    IArchitectureConfiguration? configuration = null,
-    IEnvironment? environment = null,
+    IEnvironment? environment = null,
-    IArchitectureServices? services = null,
+    IArchitectureServices? services = null,
-    IArchitectureContext? context = null)
+    IArchitectureContext? context = null)
-{
+{
-    Configuration = configuration ?? new ArchitectureConfiguration();
+    var resolvedConfiguration = configuration ?? new ArchitectureConfiguration();
-    Environment = environment ?? new DefaultEnvironment();
+    var resolvedEnvironment = environment ?? new DefaultEnvironment();
-    Services = services ?? new ArchitectureServices();
+    var resolvedServices = services ?? new ArchitectureServices();
-    _context = context;
+    _context = context;
-
+
-    // 初始化 Logger
+    // 初始化 Logger
-    LoggerFactoryResolver.Provider = Configuration.LoggerProperties.LoggerFactoryProvider;
+    LoggerFactoryResolver.Provider = resolvedConfiguration.LoggerProperties.LoggerFactoryProvider;
-    _logger = LoggerFactoryResolver.Provider.CreateLogger(GetType().Name);
+    _logger = LoggerFactoryResolver.Provider.CreateLogger(GetType().Name);
-
+
-    // 初始化管理器
+    // 初始化协作者
-    _lifecycle = new ArchitectureLifecycle(this, Configuration, Services, _logger);
+    _bootstrapper = new ArchitectureBootstrapper(GetType(), resolvedEnvironment, resolvedServices, _logger);
-    _componentRegistry = new ArchitectureComponentRegistry(this, Configuration, Services, _lifecycle, _logger);
+    _lifecycle = new ArchitectureLifecycle(this, resolvedConfiguration, resolvedServices, _logger);
-    _modules = new ArchitectureModules(this, Services, _logger);
+    _componentRegistry = new ArchitectureComponentRegistry(this, resolvedConfiguration, resolvedServices, _lifecycle, _logger);
-}
+    _modules = new ArchitectureModules(this, resolvedServices, _logger);
-```
+}
+```
 
 **优势**:
 
@@ -189,19 +197,20 @@ architecture.RegisterLifecycleHook(new MyLifecycleHook());
 1. 创建 Architecture 实例
    └─> 构造函数初始化管理器
 
-2. 调用 InitializeAsync() 或 Initialize()
+2. 调用 InitializeAsync() 或 Initialize()
-   ├─> 初始化环境 (Environment.Initialize())
+   ├─> ArchitectureBootstrapper 准备基础设施
-   ├─> 注册内置服务模块
+   │   ├─> 初始化环境 (Environment.Initialize())
-   ├─> 初始化架构上下文
+   │   ├─> 注册内置服务模块
-   ├─> 执行服务钩子
+   │   ├─> 初始化架构上下文并绑定 GameContext
-   ├─> 初始化服务模块
+   │   ├─> 执行服务钩子
-   ├─> 调用 OnInitialize() (用户注册组件)
+   │   └─> 初始化服务模块
-   ├─> 初始化所有组件
+   ├─> 调用 OnInitialize() (用户注册组件)
-   │   ├─> BeforeUtilityInit → 初始化 Utility → AfterUtilityInit
+   ├─> 初始化所有组件
-   │   ├─> BeforeModelInit → 初始化 Model → AfterModelInit
+   │   ├─> BeforeUtilityInit → 初始化 Utility → AfterUtilityInit
-   │   └─> BeforeSystemInit → 初始化 System → AfterSystemInit
+   │   ├─> BeforeModelInit → 初始化 Model → AfterModelInit
-   ├─> 冻结 IoC 容器
+   │   └─> BeforeSystemInit → 初始化 System → AfterSystemInit
-   └─> 进入 Ready 阶段
+   ├─> CompleteInitialization() 冻结 IoC 容器
+   └─> 进入 Ready 阶段
 
 3. 等待就绪 (可选)
    └─> await architecture.WaitUntilReadyAsync()
@@ -210,16 +219,16 @@ architecture.RegisterLifecycleHook(new MyLifecycleHook());
 ### 销毁流程
 
 ```
-1. 调用 DestroyAsync() 或 Destroy()
+1. 调用 DestroyAsync() 或 Destroy()
-   ├─> 检查当前阶段 (如果是 None 或已销毁则直接返回)
+   ├─> 检查当前阶段 (如果是 None 或已销毁则直接返回)
-   ├─> 进入 Destroying 阶段
+   ├─> 进入 Destroying 阶段
-   ├─> 逆序销毁所有组件
+   ├─> 逆序销毁所有组件
-   │   ├─> 优先调用 IAsyncDestroyable.DestroyAsync()
+   │   ├─> 优先调用 IAsyncDestroyable.DestroyAsync()
-   │   └─> 否则调用 IDestroyable.Destroy()
+   │   └─> 否则调用 IDestroyable.Destroy()
-   ├─> 销毁服务模块
+   ├─> 销毁服务模块
-   ├─> 清空 IoC 容器
+   ├─> 进入 Destroyed 阶段
-   └─> 进入 Destroyed 阶段
+   └─> 清空 IoC 容器
-```
+```
 
 ---
 

docs/zh-CN/core/cqrs.md

@@ -216,15 +216,20 @@ public class GameArchitecture : Architecture
 {
     protected override void Init()
     {
-        // 注册 Mediator 行为
+        // 注册通用开放泛型行为
-        RegisterMediatorBehavior<LoggingBehavior>();
+        RegisterMediatorBehavior<LoggingBehavior<,>>();
-        RegisterMediatorBehavior<PerformanceBehavior>();
+        RegisterMediatorBehavior<PerformanceBehavior<,>>();
 
         // 处理器会自动通过依赖注入注册
     }
 }
 ```
 
+`RegisterMediatorBehavior<TBehavior>()` 同时支持两种形式：
+
+- 开放泛型行为，例如 `LoggingBehavior<,>`，用于匹配所有请求
+- 封闭行为类型，例如某个只服务于单一请求的 `SpecialBehavior`
+
 ## 高级用法
 
 ### Request（请求）

docs/zh-CN/core/index.md

@@ -319,7 +319,7 @@ public class PlayerController : IController
 
 ### Architecture 内部结构 (v1.1.0+)
 
-从 v1.1.0 开始,Architecture 类采用模块化设计,将原本 708 行的单一类拆分为 4 个职责清晰的类:
+从 v1.1.0 开始,Architecture 类采用模块化设计,将原本 708 行的单一类拆分为多个职责清晰的协作者:
 
 #### 1. Architecture (核心协调器)
 
@@ -338,10 +338,22 @@ public class PlayerController : IController
 
 - `PhaseChanged` - 阶段变更事件
 
-#### 2. ArchitectureLifecycle (生命周期管理器)
+#### 2. ArchitectureBootstrapper (初始化基础设施编排器)
-
+
-**职责**: 管理架构的生命周期和阶段转换
+**职责**: 在用户 `OnInitialize()` 执行前准备环境、服务和上下文，并在组件初始化完成后执行初始化收尾
-
+
+**核心功能**:
+
+- 初始化环境对象
+- 注册内置服务模块
+- 绑定架构上下文到 `GameContext`
+- 执行服务钩子
+- 在 `InitializeAllComponentsAsync()` 完成后通过 `CompleteInitialization()` 冻结 IoC 容器
+
+#### 3. ArchitectureLifecycle (生命周期管理器)
+
+**职责**: 管理架构的生命周期和阶段转换
+
 **核心功能**:
 
 - 11 个架构阶段的管理和转换
@@ -355,11 +367,11 @@ public class PlayerController : IController
 - `EnterPhase()` - 进入指定阶段
 - `RegisterLifecycleHook()` - 注册生命周期钩子
 - `InitializeAllComponentsAsync()` - 初始化所有组件
-- `DestroyAsync()` - 异步销毁
+- `DestroyAsync()` - 异步销毁
-
+
-#### 3. ArchitectureComponentRegistry (组件注册管理器)
+#### 4. ArchitectureComponentRegistry (组件注册管理器)
-
+
-**职责**: 管理 System、Model、Utility 的注册
+**职责**: 管理 System、Model、Utility 的注册
 
 **核心功能**:
 
@@ -370,11 +382,14 @@ public class PlayerController : IController
 
 **关键方法**:
 
-- `RegisterSystem<T>()` - 注册系统
+- `RegisterSystem<T>()` - 注册系统
-- `RegisterModel<T>()` - 注册模型
+- `RegisterModel<T>()` - 注册模型
-- `RegisterUtility<T>()` - 注册工具
+- `RegisterUtility<T>()` - 注册工具
-
+
-#### 4. ArchitectureModules (模块管理器)
+> 命名提醒: 公开的 `ArchitectureServices` 负责容器和基础服务,并不承担组件注册职责。
+> `ArchitectureComponentRegistry` 才是内部的 System / Model / Utility 注册器。
+
+#### 5. ArchitectureModules (模块管理器)
 
 **职责**: 管理架构模块和中介行为
 
@@ -429,23 +444,26 @@ public class PlayerController : IController
 ### 1. 初始化流程
 
 ```
-创建 Architecture 实例
+创建 Architecture 实例
-    └─> 构造函数
+    └─> 构造函数
-        ├─> 初始化 Logger
+        ├─> 初始化 Logger
-        ├─> 创建 ArchitectureLifecycle
+        ├─> 创建 ArchitectureBootstrapper
-        ├─> 创建 ArchitectureComponentRegistry
+        ├─> 创建 ArchitectureLifecycle
-        └─> 创建 ArchitectureModules
+        ├─> 创建 ArchitectureComponentRegistry
-    └─> InitializeAsync()
+        └─> 创建 ArchitectureModules
-        ├─> OnInitialize() (用户注册组件)
+    └─> InitializeAsync()
-        │   ├─> RegisterModel → Model.SetContext()
+        ├─> Bootstrapper 准备环境/服务/上下文
-        │   ├─> RegisterSystem → System.SetContext()
+        ├─> OnInitialize() (用户注册组件)
-        │   └─> RegisterUtility → 注册到容器
+        │   ├─> RegisterModel → Model.SetContext()
-        └─> InitializeAllComponentsAsync()
+        │   ├─> RegisterSystem → System.SetContext()
-            ├─> BeforeUtilityInit → Utility.Initialize()
+        │   └─> RegisterUtility → 注册到容器
-            ├─> BeforeModelInit → Model.Initialize()
+        ├─> InitializeAllComponentsAsync()
-            ├─> BeforeSystemInit → System.Initialize()
+        │   ├─> BeforeUtilityInit → Utility.Initialize()
-            └─> Ready
+        │   ├─> BeforeModelInit → Model.Initialize()
-```
+        │   └─> BeforeSystemInit → System.Initialize()
+        ├─> CompleteInitialization() → 冻结 IoC 容器
+        └─> 进入 Ready
+```
 
 **重要变更 (v1.1.0)**: 管理器现在在构造函数中初始化,而不是在 InitializeAsync 中。这消除了 `null!` 断言,提高了代码安全性。