gewuyou/GFramework
1
0
Fork 0
mirror of https://github.com/GeWuYou/GFramework.git synced 2026-03-22 10:34:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

style(csharp): 格式化代码样式和优化代码结构

Browse Source 
- 统一调整代码注释的缩进格式，保持文档注释的一致性
- 简化对象初始化语法，移除不必要的参数名称指定
- 优化条件语句结构，移除多余的花括号
- 调整方法实现格式，使用表达式主体语法简化代码
- 标准化代码缩进和空格使用，提升代码可读性
- [skip ci]
This commit is contained in:
GwWuYou 2026-01-04 22:14:34 +08:00
parent 18267e7c14
commit f87c9cf421
61 changed files with 364 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
GFramework.Core.Abstractions/architecture/IArchitectureServices.cs
View File

@ -24,12 +24,12 @@ public interface IArchitectureServices : IContextAware
ITypeEventSystem TypeEventSystem { get; } ITypeEventSystem TypeEventSystem { get; }
/// <summary> /// <summary>
/// 获取命令总线 /// 获取命令总线
/// </summary> /// </summary>
public ICommandBus CommandBus { get; } public ICommandBus CommandBus { get; }
/// <summary> /// <summary>
/// 获取查询总线 /// 获取查询总线
/// </summary> /// </summary>
public IQueryBus QueryBus { get; } public IQueryBus QueryBus { get; }
} }

6
GFramework.Core.Abstractions/command/ICommandBus.cs
View File

@ -1,18 +1,18 @@
namespace GFramework.Core.Abstractions.command; namespace GFramework.Core.Abstractions.command;
/// <summary> /// <summary>
/// 定义命令总线接口，用于执行各种命令 /// 定义命令总线接口，用于执行各种命令
/// </summary> /// </summary>
public interface ICommandBus public interface ICommandBus
{ {
/// <summary> /// <summary>
/// 发送并执行一个命令 /// 发送并执行一个命令
/// </summary> /// </summary>
/// <param name="command">要执行的命令对象</param> /// <param name="command">要执行的命令对象</param>
public void Send(ICommand command); public void Send(ICommand command);
/// <summary> /// <summary>
/// 发送并执行一个带返回值的命令 /// 发送并执行一个带返回值的命令
/// </summary> /// </summary>
/// <typeparam name="TResult">命令执行结果的类型</typeparam> /// <typeparam name="TResult">命令执行结果的类型</typeparam>
/// <param name="command">要执行的带返回值的命令对象</param> /// <param name="command">要执行的带返回值的命令对象</param>

4
GFramework.Core.Abstractions/command/ICommandInput.cs
View File

@ -1,7 +1,7 @@
namespace GFramework.Core.Abstractions.command; namespace GFramework.Core.Abstractions.command;
/// <summary> /// <summary>
/// 命令输入接口，定义命令模式中输入数据的契约 /// 命令输入接口，定义命令模式中输入数据的契约
/// 该接口作为标记接口使用，不包含任何成员定义 /// 该接口作为标记接口使用，不包含任何成员定义
/// </summary> /// </summary>
public interface ICommandInput; public interface ICommandInput;

6
GFramework.Core.Abstractions/controller/IController.cs
View File

@ -1,10 +1,10 @@
namespace GFramework.Core.Abstractions.controller; namespace GFramework.Core.Abstractions.controller;
/// <summary> /// <summary>
/// 控制器接口，定义了控制器的基本契约和行为规范 /// 控制器接口，定义了控制器的基本契约和行为规范
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// 该接口为框架中的控制器组件提供统一的抽象定义， /// 该接口为框架中的控制器组件提供统一的抽象定义，
/// 用于实现控制器的标准功能和生命周期管理 /// 用于实现控制器的标准功能和生命周期管理
/// </remarks> /// </remarks>
public interface IController; public interface IController;

14
GFramework.Core.Abstractions/environment/IEnvironment.cs
View File

@ -1,18 +1,18 @@
namespace GFramework.Core.Abstractions.environment; namespace GFramework.Core.Abstractions.environment;
/// <summary> /// <summary>
/// 定义环境接口，提供应用程序运行环境的相关信息 /// 定义环境接口，提供应用程序运行环境的相关信息
/// </summary> /// </summary>
public interface IEnvironment public interface IEnvironment
{ {
/// <summary> /// <summary>
/// 获取环境名称 /// 获取环境名称
/// </summary> /// </summary>
public string Name { get; } public string Name { get; }
/// <summary> /// <summary>
/// 根据键值获取指定类型的环境配置值 /// 根据键值获取指定类型的环境配置值
/// </summary> /// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam> /// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找配置值的键</param> /// <param name="key">用于查找配置值的键</param>
@ -20,7 +20,7 @@ public interface IEnvironment
T? Get<T>(string key) where T : class; T? Get<T>(string key) where T : class;
/// <summary> /// <summary>
/// 尝试获取环境值（显式判断） /// 尝试获取环境值（显式判断）
/// </summary> /// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam> /// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找配置值的键</param> /// <param name="key">用于查找配置值的键</param>
@ -29,7 +29,7 @@ public interface IEnvironment
bool TryGet<T>(string key, out T value) where T : class; bool TryGet<T>(string key, out T value) where T : class;
/// <summary> /// <summary>
/// 获取必须存在的环境值（强依赖） /// 获取必须存在的环境值（强依赖）
/// </summary> /// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam> /// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找配置值的键</param> /// <param name="key">用于查找配置值的键</param>
@ -37,14 +37,14 @@ public interface IEnvironment
T GetRequired<T>(string key) where T : class; T GetRequired<T>(string key) where T : class;
/// <summary> /// <summary>
/// 注册键值对到环境值字典中 /// 注册键值对到环境值字典中
/// </summary> /// </summary>
/// <param name="key">要注册的键</param> /// <param name="key">要注册的键</param>
/// <param name="value">要注册的值</param> /// <param name="value">要注册的值</param>
void Register(string key, object value); void Register(string key, object value);
/// <summary> /// <summary>
/// 初始化环境值字典 /// 初始化环境值字典
/// </summary> /// </summary>
void Initialize(); void Initialize();
} }

6
GFramework.Core.Abstractions/logging/ILoggerFactoryProvider.cs
View File

@ -1,17 +1,17 @@
namespace GFramework.Core.Abstractions.logging; namespace GFramework.Core.Abstractions.logging;
/// <summary> /// <summary>
/// 定义日志工厂提供者的接口，用于创建具有指定名称和最小日志级别的日志记录器 /// 定义日志工厂提供者的接口，用于创建具有指定名称和最小日志级别的日志记录器
/// </summary> /// </summary>
public interface ILoggerFactoryProvider public interface ILoggerFactoryProvider
{ {
/// <summary> /// <summary>
/// 获取或设置日志记录器的最小日志级别，低于此级别的日志将被忽略 /// 获取或设置日志记录器的最小日志级别，低于此级别的日志将被忽略
/// </summary> /// </summary>
public LogLevel MinLevel { get; set; } public LogLevel MinLevel { get; set; }
/// <summary> /// <summary>
/// 创建一个日志记录器实例 /// 创建一个日志记录器实例
/// </summary> /// </summary>
/// <param name="name">日志记录器的名称，用于标识特定的日志源</param> /// <param name="name">日志记录器的名称，用于标识特定的日志源</param>
/// <returns>配置了指定名称和最小日志级别的ILogger实例</returns> /// <returns>配置了指定名称和最小日志级别的ILogger实例</returns>

4
GFramework.Core.Abstractions/query/IQueryBus.cs
View File

@ -1,12 +1,12 @@
namespace GFramework.Core.Abstractions.query; namespace GFramework.Core.Abstractions.query;
/// <summary> /// <summary>
/// 查询总线接口，用于发送和处理查询请求 /// 查询总线接口，用于发送和处理查询请求
/// </summary> /// </summary>
public interface IQueryBus public interface IQueryBus
{ {
/// <summary> /// <summary>
/// 发送查询请求并返回结果 /// 发送查询请求并返回结果
/// </summary> /// </summary>
/// <typeparam name="TResult">查询结果的类型</typeparam> /// <typeparam name="TResult">查询结果的类型</typeparam>
/// <param name="query">要发送的查询对象</param> /// <param name="query">要发送的查询对象</param>

2
GFramework.Core.Abstractions/query/IQueryInput.cs
View File

@ -1,6 +1,6 @@
namespace GFramework.Core.Abstractions.query; namespace GFramework.Core.Abstractions.query;
/// <summary> /// <summary>
/// 查询输入接口，定义了查询操作的输入规范 /// 查询输入接口，定义了查询操作的输入规范
/// </summary> /// </summary>
public interface IQueryInput; public interface IQueryInput;

4
GFramework.Core.Tests/architecture/AsyncTestArchitecture.cs
View File

@ -4,12 +4,12 @@ using GFramework.Core.Tests.system;
namespace GFramework.Core.Tests.architecture; namespace GFramework.Core.Tests.architecture;
/// <summary> /// <summary>
/// 异步测试架构，用于测试异步模型和系统的初始化 /// 异步测试架构，用于测试异步模型和系统的初始化
/// </summary> /// </summary>
public class AsyncTestArchitecture : TestArchitectureBase public class AsyncTestArchitecture : TestArchitectureBase
{ {
/// <summary> /// <summary>
/// 异步初始化架构 /// 异步初始化架构
/// </summary> /// </summary>
protected override void Init() protected override void Init()
{ {

4
GFramework.Core.Tests/architecture/SyncTestArchitecture.cs
View File

@ -4,12 +4,12 @@ using GFramework.Core.Tests.system;
namespace GFramework.Core.Tests.architecture; namespace GFramework.Core.Tests.architecture;
/// <summary> /// <summary>
/// 同步测试架构类，用于测试架构的生命周期和事件处理 /// 同步测试架构类，用于测试架构的生命周期和事件处理
/// </summary> /// </summary>
public sealed class SyncTestArchitecture : TestArchitectureBase public sealed class SyncTestArchitecture : TestArchitectureBase
{ {
/// <summary> /// <summary>
/// 初始化架构组件，注册模型、系统并设置事件监听器 /// 初始化架构组件，注册模型、系统并设置事件监听器
/// </summary> /// </summary>
protected override void Init() protected override void Init()
{ {

19
GFramework.Core.Tests/architecture/TestArchitectureBase.cs
View File

@ -5,35 +5,38 @@ using GFramework.Core.events;
namespace GFramework.Core.Tests.architecture; namespace GFramework.Core.Tests.architecture;
/// <summary> /// <summary>
/// 测试架构基类，提供通用的测试架构功能 /// 测试架构基类，提供通用的测试架构功能
/// </summary> /// </summary>
public abstract class TestArchitectureBase : Architecture public abstract class TestArchitectureBase : Architecture
{ {
private Action<TestArchitectureBase>? _postRegistrationHook; private Action<TestArchitectureBase>? _postRegistrationHook;
/// <summary> /// <summary>
/// 获取就绪事件是否已触发的状态 /// 获取就绪事件是否已触发的状态
/// </summary> /// </summary>
public bool ReadyEventFired { get; protected set; } public bool ReadyEventFired { get; protected set; }
/// <summary> /// <summary>
/// 获取初始化方法是否已调用的状态 /// 获取初始化方法是否已调用的状态
/// </summary> /// </summary>
public bool InitCalled { get; protected set; } public bool InitCalled { get; protected set; }
/// <summary> /// <summary>
/// 获取架构阶段历史记录列表 /// 获取架构阶段历史记录列表
/// </summary> /// </summary>
public List<ArchitecturePhase> PhaseHistory { get; } = []; public List<ArchitecturePhase> PhaseHistory { get; } = [];
/// <summary> /// <summary>
/// 添加注册后钩子函数 /// 添加注册后钩子函数
/// </summary> /// </summary>
/// <param name="hook">要添加的钩子函数</param> /// <param name="hook">要添加的钩子函数</param>
public void AddPostRegistrationHook(Action<TestArchitectureBase> hook) => _postRegistrationHook = hook; public void AddPostRegistrationHook(Action<TestArchitectureBase> hook)
{
_postRegistrationHook = hook;
}
/// <summary> /// <summary>
/// 初始化架构组件，注册模型、系统并设置事件监听器 /// 初始化架构组件，注册模型、系统并设置事件监听器
/// </summary> /// </summary>
protected override void Init() protected override void Init()
{ {
@ -43,7 +46,7 @@ public abstract class TestArchitectureBase : Architecture
} }
/// <summary> /// <summary>
/// 进入指定架构阶段时的处理方法，记录阶段历史 /// 进入指定架构阶段时的处理方法，记录阶段历史
/// </summary> /// </summary>
/// <param name="next">要进入的下一个架构阶段</param> /// <param name="next">要进入的下一个架构阶段</param>
protected override void EnterPhase(ArchitecturePhase next) protected override void EnterPhase(ArchitecturePhase next)

19
GFramework.Core.Tests/model/AsyncTestModel.cs
View File

@ -5,19 +5,19 @@ using GFramework.Core.Abstractions.model;
namespace GFramework.Core.Tests.model; namespace GFramework.Core.Tests.model;
/// <summary> /// <summary>
/// 异步测试模型类，实现了IModel和IAsyncInitializable接口 /// 异步测试模型类，实现了IModel和IAsyncInitializable接口
/// </summary> /// </summary>
public sealed class AsyncTestModel : IModel, IAsyncInitializable public sealed class AsyncTestModel : IModel, IAsyncInitializable
{ {
private IArchitectureContext _context = null!; private IArchitectureContext _context = null!;
/// <summary> /// <summary>
/// 获取模型是否已初始化的标志 /// 获取模型是否已初始化的标志
/// </summary> /// </summary>
public bool Initialized { get; private set; } public bool Initialized { get; private set; }
/// <summary> /// <summary>
/// 异步初始化方法，模拟异步初始化过程 /// 异步初始化方法，模拟异步初始化过程
/// </summary> /// </summary>
/// <returns>表示异步操作的Task</returns> /// <returns>表示异步操作的Task</returns>
public async Task InitializeAsync() public async Task InitializeAsync()
@ -27,7 +27,7 @@ public sealed class AsyncTestModel : IModel, IAsyncInitializable
} }
/// <summary> /// <summary>
/// 同步初始化方法，该方法不应该被调用 /// 同步初始化方法，该方法不应该被调用
/// </summary> /// </summary>
/// <exception cref="InvalidOperationException">当该方法被调用时抛出异常</exception> /// <exception cref="InvalidOperationException">当该方法被调用时抛出异常</exception>
public void Init() public void Init()
@ -37,7 +37,7 @@ public sealed class AsyncTestModel : IModel, IAsyncInitializable
} }
/// <summary> /// <summary>
/// 设置架构上下文 /// 设置架构上下文
/// </summary> /// </summary>
/// <param name="context">架构上下文对象</param> /// <param name="context">架构上下文对象</param>
public void SetContext(IArchitectureContext context) public void SetContext(IArchitectureContext context)
@ -46,13 +46,16 @@ public sealed class AsyncTestModel : IModel, IAsyncInitializable
} }
/// <summary> /// <summary>
/// 获取架构上下文 /// 获取架构上下文
/// </summary> /// </summary>
/// <returns>架构上下文对象</returns> /// <returns>架构上下文对象</returns>
public IArchitectureContext GetContext() => _context; public IArchitectureContext GetContext()
{
return _context;
}
/// <summary> /// <summary>
/// 处理架构阶段事件 /// 处理架构阶段事件
/// </summary> /// </summary>
/// <param name="phase">架构阶段枚举值</param> /// <param name="phase">架构阶段枚举值</param>
public void OnArchitecturePhase(ArchitecturePhase phase) public void OnArchitecturePhase(ArchitecturePhase phase)

20
GFramework.Core.Tests/model/FailingModel.cs
View File

@ -5,14 +5,14 @@ using GFramework.Core.Abstractions.model;
namespace GFramework.Core.Tests.model; namespace GFramework.Core.Tests.model;
/// <summary> /// <summary>
/// 一个用于测试的失败模型类，实现IModel接口 /// 一个用于测试的失败模型类，实现IModel接口
/// 该模型在初始化时会故意抛出异常，用于测试异常处理机制 /// 该模型在初始化时会故意抛出异常，用于测试异常处理机制
/// </summary> /// </summary>
public sealed class FailingModel : IModel public sealed class FailingModel : IModel
{ {
/// <summary> /// <summary>
/// 初始化模型 /// 初始化模型
/// 该方法会故意抛出InvalidOperationException异常 /// 该方法会故意抛出InvalidOperationException异常
/// </summary> /// </summary>
/// <exception cref="InvalidOperationException">总是抛出此异常以模拟初始化失败</exception> /// <exception cref="InvalidOperationException">总是抛出此异常以模拟初始化失败</exception>
public void Init() public void Init()
@ -21,8 +21,8 @@ public sealed class FailingModel : IModel
} }
/// <summary> /// <summary>
/// 设置架构上下文 /// 设置架构上下文
/// 该方法为空实现，不执行任何操作 /// 该方法为空实现，不执行任何操作
/// </summary> /// </summary>
/// <param name="context">架构上下文对象</param> /// <param name="context">架构上下文对象</param>
public void SetContext(IArchitectureContext context) public void SetContext(IArchitectureContext context)
@ -30,8 +30,8 @@ public sealed class FailingModel : IModel
} }
/// <summary> /// <summary>
/// 获取架构上下文 /// 获取架构上下文
/// 该方法会抛出NotSupportedException异常 /// 该方法会抛出NotSupportedException异常
/// </summary> /// </summary>
/// <returns>不返回任何值，总是抛出异常</returns> /// <returns>不返回任何值，总是抛出异常</returns>
/// <exception cref="NotSupportedException">总是抛出此异常</exception> /// <exception cref="NotSupportedException">总是抛出此异常</exception>
@ -41,8 +41,8 @@ public sealed class FailingModel : IModel
} }
/// <summary> /// <summary>
/// 处理架构阶段事件 /// 处理架构阶段事件
/// 该方法为空实现，不执行任何操作 /// 该方法为空实现，不执行任何操作
/// </summary> /// </summary>
/// <param name="phase">当前架构阶段</param> /// <param name="phase">当前架构阶段</param>
public void OnArchitecturePhase(ArchitecturePhase phase) public void OnArchitecturePhase(ArchitecturePhase phase)

6
GFramework.Core.Tests/model/TestModel.cs
View File

@ -5,19 +5,19 @@ using GFramework.Core.Abstractions.model;
namespace GFramework.Core.Tests.model; namespace GFramework.Core.Tests.model;
/// <summary> /// <summary>
/// 测试模型类，用于框架测试目的 /// 测试模型类，用于框架测试目的
/// </summary> /// </summary>
public sealed class TestModel : IModel public sealed class TestModel : IModel
{ {
private IArchitectureContext _context = null!; private IArchitectureContext _context = null!;
/// <summary> /// <summary>
/// 获取模型是否已初始化的状态 /// 获取模型是否已初始化的状态
/// </summary> /// </summary>
public bool Initialized { get; private set; } public bool Initialized { get; private set; }
/// <summary> /// <summary>
/// 初始化模型 /// 初始化模型
/// </summary> /// </summary>
public void Init() public void Init()
{ {

18
GFramework.Core.Tests/system/AsyncTestSystem.cs
View File

@ -5,7 +5,7 @@ using GFramework.Core.Abstractions.system;
namespace GFramework.Core.Tests.system; namespace GFramework.Core.Tests.system;
/// <summary> /// <summary>
/// 异步测试系统，实现 ISystem 和 IAsyncInitializable /// 异步测试系统，实现 ISystem 和 IAsyncInitializable
/// </summary> /// </summary>
public sealed class AsyncTestSystem : ISystem, IAsyncInitializable public sealed class AsyncTestSystem : ISystem, IAsyncInitializable
{ {
@ -19,8 +19,15 @@ public sealed class AsyncTestSystem : ISystem, IAsyncInitializable
Initialized = true; Initialized = true;
} }
public void SetContext(IArchitectureContext context) => _context = context; public void SetContext(IArchitectureContext context)
public IArchitectureContext GetContext() => _context; {
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
public void Init() public void Init()
{ {
@ -28,7 +35,10 @@ public sealed class AsyncTestSystem : ISystem, IAsyncInitializable
throw new InvalidOperationException("Sync Init should not be called"); throw new InvalidOperationException("Sync Init should not be called");
} }
public void Destroy() => DestroyCalled = true; public void Destroy()
{
DestroyCalled = true;
}
public void OnArchitecturePhase(ArchitecturePhase phase) public void OnArchitecturePhase(ArchitecturePhase phase)
{ {

16
GFramework.Core.Tests/system/TestSystem.cs
View File

@ -5,27 +5,27 @@ using GFramework.Core.Abstractions.system;
namespace GFramework.Core.Tests.system; namespace GFramework.Core.Tests.system;
/// <summary> /// <summary>
/// 测试系统类，实现了ISystem接口 /// 测试系统类，实现了ISystem接口
/// </summary> /// </summary>
public sealed class TestSystem : ISystem public sealed class TestSystem : ISystem
{ {
/// <summary> /// <summary>
/// 架构上下文对象 /// 架构上下文对象
/// </summary> /// </summary>
private IArchitectureContext _context = null!; private IArchitectureContext _context = null!;
/// <summary> /// <summary>
/// 获取系统是否已初始化的状态 /// 获取系统是否已初始化的状态
/// </summary> /// </summary>
public bool Initialized { get; private set; } public bool Initialized { get; private set; }
/// <summary> /// <summary>
/// 获取系统是否已销毁的状态 /// 获取系统是否已销毁的状态
/// </summary> /// </summary>
public bool DestroyCalled { get; private set; } public bool DestroyCalled { get; private set; }
/// <summary> /// <summary>
/// 设置架构上下文 /// 设置架构上下文
/// </summary> /// </summary>
/// <param name="context">架构上下文对象</param> /// <param name="context">架构上下文对象</param>
public void SetContext(IArchitectureContext context) public void SetContext(IArchitectureContext context)
@ -34,7 +34,7 @@ public sealed class TestSystem : ISystem
} }
/// <summary> /// <summary>
/// 获取架构上下文 /// 获取架构上下文
/// </summary> /// </summary>
/// <returns>架构上下文对象</returns> /// <returns>架构上下文对象</returns>
public IArchitectureContext GetContext() public IArchitectureContext GetContext()
@ -43,7 +43,7 @@ public sealed class TestSystem : ISystem
} }
/// <summary> /// <summary>
/// 初始化系统 /// 初始化系统
/// </summary> /// </summary>
public void Init() public void Init()
{ {
@ -51,7 +51,7 @@ public sealed class TestSystem : ISystem
} }
/// <summary> /// <summary>
/// 销毁系统 /// 销毁系统
/// </summary> /// </summary>
public void Destroy() public void Destroy()
{ {

16
GFramework.Core.Tests/tests/ArchitectureTestsBase.cs
View File

@ -5,7 +5,7 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.tests; namespace GFramework.Core.Tests.tests;
/// <summary> /// <summary>
/// 架构测试基类，封装同步/异步共通测试逻辑 /// 架构测试基类，封装同步/异步共通测试逻辑
/// </summary> /// </summary>
/// <typeparam name="TArchitecture">架构类型，必须继承自Architecture</typeparam> /// <typeparam name="TArchitecture">架构类型，必须继承自Architecture</typeparam>
public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture : Architecture public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture : Architecture
@ -13,14 +13,14 @@ public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture :
protected TArchitecture? Architecture; protected TArchitecture? Architecture;
/// <summary> /// <summary>
/// 子类必须实现创建具体架构实例 /// 子类必须实现创建具体架构实例
/// </summary> /// </summary>
/// <returns>创建的架构实例</returns> /// <returns>创建的架构实例</returns>
protected abstract TArchitecture CreateArchitecture(); protected abstract TArchitecture CreateArchitecture();
/// <summary> /// <summary>
/// 测试设置方法，在每个测试开始前执行 /// 测试设置方法，在每个测试开始前执行
/// 清理游戏上下文并创建架构实例 /// 清理游戏上下文并创建架构实例
/// </summary> /// </summary>
[SetUp] [SetUp]
public void SetUp() public void SetUp()
@ -30,8 +30,8 @@ public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture :
} }
/// <summary> /// <summary>
/// 测试清理方法，在每个测试结束后执行 /// 测试清理方法，在每个测试结束后执行
/// 销毁架构实例并清理游戏上下文 /// 销毁架构实例并清理游戏上下文
/// </summary> /// </summary>
[TearDown] [TearDown]
public void TearDown() public void TearDown()
@ -48,8 +48,8 @@ public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture :
} }
/// <summary> /// <summary>
/// 验证架构初始化失败的断言方法 /// 验证架构初始化失败的断言方法
/// 检查当前架构阶段是否为初始化失败状态 /// 检查当前架构阶段是否为初始化失败状态
/// </summary> /// </summary>
protected void AssertInitializationFailed() protected void AssertInitializationFailed()
{ {

25
GFramework.Core.Tests/tests/AsyncArchitectureTests.cs
View File

@ -8,23 +8,26 @@ using NUnit.Framework.Legacy;
namespace GFramework.Core.Tests.tests; namespace GFramework.Core.Tests.tests;
/// <summary> /// <summary>
/// 异步架构测试类，用于测试异步架构的相关功能 /// 异步架构测试类，用于测试异步架构的相关功能
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// 该测试类使用非并行执行模式，确保测试的隔离性 /// 该测试类使用非并行执行模式，确保测试的隔离性
/// </remarks> /// </remarks>
[TestFixture] [TestFixture]
[NonParallelizable] [NonParallelizable]
public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitecture> public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitecture>
{ {
/// <summary> /// <summary>
/// 创建异步测试架构实例 /// 创建异步测试架构实例
/// </summary> /// </summary>
/// <returns>AsyncTestArchitecture实例</returns> /// <returns>AsyncTestArchitecture实例</returns>
protected override AsyncTestArchitecture CreateArchitecture() => new(); protected override AsyncTestArchitecture CreateArchitecture()
{
return new AsyncTestArchitecture();
}
/// <summary> /// <summary>
/// 测试架构是否正确初始化所有组件 /// 测试架构是否正确初始化所有组件
/// </summary> /// </summary>
/// <returns>异步任务</returns> /// <returns>异步任务</returns>
[Test] [Test]
@ -45,7 +48,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
} }
/// <summary> /// <summary>
/// 测试架构是否按正确顺序进入各个阶段 /// 测试架构是否按正确顺序进入各个阶段
/// </summary> /// </summary>
/// <returns>异步任务</returns> /// <returns>异步任务</returns>
[Test] [Test]
@ -68,7 +71,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
} }
/// <summary> /// <summary>
/// 测试在就绪状态后注册模型是否抛出异常 /// 测试在就绪状态后注册模型是否抛出异常
/// </summary> /// </summary>
/// <returns>异步任务</returns> /// <returns>异步任务</returns>
[Test] [Test]
@ -81,7 +84,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
} }
/// <summary> /// <summary>
/// 测试当模型初始化失败时架构是否停止初始化 /// 测试当模型初始化失败时架构是否停止初始化
/// </summary> /// </summary>
/// <returns>异步任务</returns> /// <returns>异步任务</returns>
[Test] [Test]
@ -98,7 +101,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
} }
/// <summary> /// <summary>
/// 测试架构销毁是否正确销毁所有系统 /// 测试架构销毁是否正确销毁所有系统
/// </summary> /// </summary>
/// <returns>异步任务</returns> /// <returns>异步任务</returns>
[Test] [Test]
@ -113,7 +116,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
} }
/// <summary> /// <summary>
/// 测试InitializeAsync方法是否不会阻塞 /// 测试InitializeAsync方法是否不会阻塞
/// </summary> /// </summary>
/// <returns>异步任务</returns> /// <returns>异步任务</returns>
[Test] [Test]
@ -126,7 +129,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
} }
/// <summary> /// <summary>
/// 测试InitializeAsync方法是否正确处理异常 /// 测试InitializeAsync方法是否正确处理异常
/// </summary> /// </summary>
/// <returns>异步任务</returns> /// <returns>异步任务</returns>
[Test] [Test]

25
GFramework.Core.Tests/tests/SyncArchitectureTests.cs
View File

@ -9,17 +9,20 @@ using NUnit.Framework.Legacy;
namespace GFramework.Core.Tests.tests; namespace GFramework.Core.Tests.tests;
/// <summary> /// <summary>
/// 同步架构测试类，用于测试同步架构的初始化、生命周期和组件注册等功能 /// 同步架构测试类，用于测试同步架构的初始化、生命周期和组件注册等功能
/// </summary> /// </summary>
[TestFixture] [TestFixture]
[NonParallelizable] [NonParallelizable]
public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture> public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
{ {
protected override SyncTestArchitecture CreateArchitecture() => new(); protected override SyncTestArchitecture CreateArchitecture()
{
return new SyncTestArchitecture();
}
/// <summary> /// <summary>
/// 测试架构是否正确初始化所有组件 /// 测试架构是否正确初始化所有组件
/// 验证初始化调用、运行时状态、架构阶段和模型系统注册 /// 验证初始化调用、运行时状态、架构阶段和模型系统注册
/// </summary> /// </summary>
[Test] [Test]
public void Architecture_Should_Initialize_All_Components_Correctly() public void Architecture_Should_Initialize_All_Components_Correctly()
@ -46,7 +49,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
} }
/// <summary> /// <summary>
/// 测试架构是否按类型正确注册上下文 /// 测试架构是否按类型正确注册上下文
/// </summary> /// </summary>
[Test] [Test]
public void Architecture_Should_Register_Context_By_Type() public void Architecture_Should_Register_Context_By_Type()
@ -59,8 +62,8 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
} }
/// <summary> /// <summary>
/// 测试架构是否按正确顺序进入各个阶段 /// 测试架构是否按正确顺序进入各个阶段
/// 验证架构初始化过程中各阶段的执行顺序 /// 验证架构初始化过程中各阶段的执行顺序
/// </summary> /// </summary>
[Test] [Test]
public void Architecture_Should_Enter_Phases_In_Correct_Order() public void Architecture_Should_Enter_Phases_In_Correct_Order()
@ -83,7 +86,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
} }
/// <summary> /// <summary>
/// 测试在架构就绪后注册系统是否抛出异常（当不允许时） /// 测试在架构就绪后注册系统是否抛出异常（当不允许时）
/// </summary> /// </summary>
[Test] [Test]
public void RegisterSystem_AfterReady_Should_Throw_When_NotAllowed() public void RegisterSystem_AfterReady_Should_Throw_When_NotAllowed()
@ -94,7 +97,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
} }
/// <summary> /// <summary>
/// 测试在架构就绪后注册模型是否抛出异常（当不允许时） /// 测试在架构就绪后注册模型是否抛出异常（当不允许时）
/// </summary> /// </summary>
[Test] [Test]
public void RegisterModel_AfterReady_Should_Throw_When_NotAllowed() public void RegisterModel_AfterReady_Should_Throw_When_NotAllowed()
@ -105,7 +108,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
} }
/// <summary> /// <summary>
/// 测试架构销毁功能，验证销毁后系统被正确销毁且架构进入销毁阶段 /// 测试架构销毁功能，验证销毁后系统被正确销毁且架构进入销毁阶段
/// </summary> /// </summary>
[Test] [Test]
public void Architecture_Destroy_Should_Destroy_All_Systems_And_Enter_Destroyed() public void Architecture_Destroy_Should_Destroy_All_Systems_And_Enter_Destroyed()
@ -121,7 +124,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
} }
/// <summary> /// <summary>
/// 测试当模型初始化失败时架构是否停止初始化 /// 测试当模型初始化失败时架构是否停止初始化
/// </summary> /// </summary>
[Test] [Test]
public void Architecture_Should_Stop_Initialization_When_Model_Init_Fails() public void Architecture_Should_Stop_Initialization_When_Model_Init_Fails()

22
GFramework.Core/architecture/Architecture.cs
View File

@ -29,18 +29,18 @@ public abstract class Architecture(
: IArchitecture : IArchitecture
{ {
/// <summary> /// <summary>
/// 获取架构配置对象 /// 获取架构配置对象
/// </summary> /// </summary>
/// <value> /// <value>
/// 返回一个IArchitectureConfiguration接口的实例，默认为DefaultArchitectureConfiguration类型 /// 返回一个IArchitectureConfiguration接口的实例，默认为DefaultArchitectureConfiguration类型
/// </value> /// </value>
private IArchitectureConfiguration Configuration { get; } = configuration ?? new ArchitectureConfiguration(); private IArchitectureConfiguration Configuration { get; } = configuration ?? new ArchitectureConfiguration();
/// <summary> /// <summary>
/// 获取环境配置对象 /// 获取环境配置对象
/// </summary> /// </summary>
/// <value> /// <value>
/// 返回一个IEnvironment接口的实例，默认为DefaultEnvironment类型 /// 返回一个IEnvironment接口的实例，默认为DefaultEnvironment类型
/// </value> /// </value>
private IEnvironment Environment { get; } = environment ?? new DefaultEnvironment(); private IEnvironment Environment { get; } = environment ?? new DefaultEnvironment();
@ -243,13 +243,13 @@ public abstract class Architecture(
#region Component Registration #region Component Registration
/// <summary> /// <summary>
/// 同步初始化方法，阻塞当前线程直到初始化完成 /// 同步初始化方法，阻塞当前线程直到初始化完成
/// </summary> /// </summary>
public void Initialize() public void Initialize()
{ {
try try
{ {
InitializeInternalAsync(asyncMode: false).GetAwaiter().GetResult(); InitializeInternalAsync(false).GetAwaiter().GetResult();
} }
catch (Exception e) catch (Exception e)
{ {
@ -261,14 +261,14 @@ public abstract class Architecture(
} }
/// <summary> /// <summary>
/// 异步初始化方法，返回Task以便调用者可以等待初始化完成 /// 异步初始化方法，返回Task以便调用者可以等待初始化完成
/// </summary> /// </summary>
/// <returns>表示异步初始化操作的Task</returns> /// <returns>表示异步初始化操作的Task</returns>
public async Task InitializeAsync() public async Task InitializeAsync()
{ {
try try
{ {
await InitializeInternalAsync(asyncMode: true); await InitializeInternalAsync(true);
} }
catch (Exception e) catch (Exception e)
{ {
@ -280,7 +280,7 @@ public abstract class Architecture(
} }
/// <summary> /// <summary>
/// 异步初始化组件 /// 异步初始化组件
/// </summary> /// </summary>
/// <param name="component">要初始化的组件对象</param> /// <param name="component">要初始化的组件对象</param>
/// <param name="asyncMode">是否启用异步模式</param> /// <param name="asyncMode">是否启用异步模式</param>
@ -289,9 +289,7 @@ public abstract class Architecture(
{ {
// 根据组件类型和异步模式选择相应的初始化方法 // 根据组件类型和异步模式选择相应的初始化方法
if (asyncMode && component is IAsyncInitializable asyncInit) if (asyncMode && component is IAsyncInitializable asyncInit)
{
await asyncInit.InitializeAsync(); await asyncInit.InitializeAsync();
}
else else
switch (component) switch (component)
{ {
@ -305,7 +303,7 @@ public abstract class Architecture(
} }
/// <summary> /// <summary>
/// 异步初始化架构内部组件，包括上下文、模型和系统的初始化 /// 异步初始化架构内部组件，包括上下文、模型和系统的初始化
/// </summary> /// </summary>
/// <param name="asyncMode">是否启用异步模式进行组件初始化</param> /// <param name="asyncMode">是否启用异步模式进行组件初始化</param>
/// <returns>异步任务，表示初始化操作的完成</returns> /// <returns>异步任务，表示初始化操作的完成</returns>

2
GFramework.Core/architecture/ArchitectureConfiguration.cs
View File

@ -17,7 +17,7 @@ public sealed class ArchitectureConfiguration : IArchitectureConfiguration
/// </summary> /// </summary>
public LoggerProperties LoggerProperties { get; set; } = new() public LoggerProperties LoggerProperties { get; set; } = new()
{ {
LoggerFactoryProvider = new ConsoleLoggerFactoryProvider() LoggerFactoryProvider = new ConsoleLoggerFactoryProvider
{ {
MinLevel = LogLevel.Info MinLevel = LogLevel.Info
} }

6
GFramework.Core/architecture/ArchitectureConstants.cs
View File

@ -4,15 +4,15 @@ using GFramework.Core.Abstractions.enums;
namespace GFramework.Core.architecture; namespace GFramework.Core.architecture;
/// <summary> /// <summary>
/// 架构常量类，定义了架构阶段转换规则 /// 架构常量类，定义了架构阶段转换规则
/// </summary> /// </summary>
public static class ArchitectureConstants public static class ArchitectureConstants
{ {
/// <summary> /// <summary>
/// 定义架构阶段之间的有效转换关系 /// 定义架构阶段之间的有效转换关系
/// </summary> /// </summary>
/// <remarks> /// <remarks>
/// 键为当前架构阶段，值为从该阶段可以转换到的下一阶段数组 /// 键为当前架构阶段，值为从该阶段可以转换到的下一阶段数组
/// </remarks> /// </remarks>
public static readonly ImmutableDictionary<ArchitecturePhase, ArchitecturePhase[]> PhaseTransitions = public static readonly ImmutableDictionary<ArchitecturePhase, ArchitecturePhase[]> PhaseTransitions =
new Dictionary<ArchitecturePhase, ArchitecturePhase[]> new Dictionary<ArchitecturePhase, ArchitecturePhase[]>

2
GFramework.Core/architecture/ArchitectureContext.cs
View File

@ -150,7 +150,7 @@ public class ArchitectureContext(
} }
/// <summary> /// <summary>
/// 获取当前环境对象 /// 获取当前环境对象
/// </summary> /// </summary>
/// <returns>环境对象实例</returns> /// <returns>环境对象实例</returns>
public IEnvironment GetEnvironment() public IEnvironment GetEnvironment()

14
GFramework.Core/architecture/ArchitectureServices.cs
View File

@ -11,34 +11,34 @@ using GFramework.Core.query;
namespace GFramework.Core.architecture; namespace GFramework.Core.architecture;
/// <summary> /// <summary>
/// 架构服务类，提供依赖注入容器、事件系统、命令总线和查询总线等核心服务 /// 架构服务类，提供依赖注入容器、事件系统、命令总线和查询总线等核心服务
/// </summary> /// </summary>
public class ArchitectureServices : IArchitectureServices public class ArchitectureServices : IArchitectureServices
{ {
private IArchitectureContext _context = null!; private IArchitectureContext _context = null!;
/// <summary> /// <summary>
/// 获取依赖注入容器 /// 获取依赖注入容器
/// </summary> /// </summary>
public IIocContainer Container { get; } = new IocContainer(); public IIocContainer Container { get; } = new IocContainer();
/// <summary> /// <summary>
/// 获取类型事件系统 /// 获取类型事件系统
/// </summary> /// </summary>
public ITypeEventSystem TypeEventSystem { get; } = new TypeEventSystem(); public ITypeEventSystem TypeEventSystem { get; } = new TypeEventSystem();
/// <summary> /// <summary>
/// 获取命令总线 /// 获取命令总线
/// </summary> /// </summary>
public ICommandBus CommandBus { get; } = new CommandBus(); public ICommandBus CommandBus { get; } = new CommandBus();
/// <summary> /// <summary>
/// 获取查询总线 /// 获取查询总线
/// </summary> /// </summary>
public IQueryBus QueryBus { get; } = new QueryBus(); public IQueryBus QueryBus { get; } = new QueryBus();
/// <summary> /// <summary>
/// 设置架构上下文 /// 设置架构上下文
/// </summary> /// </summary>
/// <param name="context">架构上下文对象</param> /// <param name="context">架构上下文对象</param>
public void SetContext(IArchitectureContext context) public void SetContext(IArchitectureContext context)
@ -48,7 +48,7 @@ public class ArchitectureServices : IArchitectureServices
} }
/// <summary> /// <summary>
/// 获取架构上下文 /// 获取架构上下文
/// </summary> /// </summary>
/// <returns>架构上下文对象</returns> /// <returns>架构上下文对象</returns>
public IArchitectureContext GetContext() public IArchitectureContext GetContext()

20
GFramework.Core/architecture/GameContext.cs
View File

@ -4,7 +4,7 @@ using GFramework.Core.Abstractions.architecture;
namespace GFramework.Core.architecture; namespace GFramework.Core.architecture;
/// <summary> /// <summary>
/// 游戏上下文管理类，用于管理当前的架构上下文实例 /// 游戏上下文管理类，用于管理当前的架构上下文实例
/// </summary> /// </summary>
public static class GameContext public static class GameContext
{ {
@ -13,13 +13,13 @@ public static class GameContext
/// <summary> /// <summary>
/// 获取所有已注册的架构上下文的只读字典 /// 获取所有已注册的架构上下文的只读字典
/// </summary> /// </summary>
public static IReadOnlyDictionary<Type, IArchitectureContext> ArchitectureReadOnlyDictionary => public static IReadOnlyDictionary<Type, IArchitectureContext> ArchitectureReadOnlyDictionary =>
ArchitectureDictionary; ArchitectureDictionary;
/// <summary> /// <summary>
/// 绑定指定类型的架构上下文到管理器中 /// 绑定指定类型的架构上下文到管理器中
/// </summary> /// </summary>
/// <param name="architectureType">架构类型</param> /// <param name="architectureType">架构类型</param>
/// <param name="context">架构上下文实例</param> /// <param name="context">架构上下文实例</param>
@ -27,14 +27,12 @@ public static class GameContext
public static void Bind(Type architectureType, IArchitectureContext context) public static void Bind(Type architectureType, IArchitectureContext context)
{ {
if (!ArchitectureDictionary.TryAdd(architectureType, context)) if (!ArchitectureDictionary.TryAdd(architectureType, context))
{
throw new InvalidOperationException( throw new InvalidOperationException(
$"Architecture context for '{architectureType.Name}' already exists"); $"Architecture context for '{architectureType.Name}' already exists");
}
} }
/// <summary> /// <summary>
/// 获取字典中的第一个架构上下文 /// 获取字典中的第一个架构上下文
/// </summary> /// </summary>
/// <returns>返回字典中的第一个架构上下文实例</returns> /// <returns>返回字典中的第一个架构上下文实例</returns>
/// <exception cref="InvalidOperationException">当字典为空时抛出</exception> /// <exception cref="InvalidOperationException">当字典为空时抛出</exception>
@ -44,7 +42,7 @@ public static class GameContext
} }
/// <summary> /// <summary>
/// 根据类型获取对应的架构上下文 /// 根据类型获取对应的架构上下文
/// </summary> /// </summary>
/// <param name="type">要查找的架构类型</param> /// <param name="type">要查找的架构类型</param>
/// <returns>返回指定类型的架构上下文实例</returns> /// <returns>返回指定类型的架构上下文实例</returns>
@ -60,7 +58,7 @@ public static class GameContext
/// <summary> /// <summary>
/// 获取指定类型的架构上下文实例 /// 获取指定类型的架构上下文实例
/// </summary> /// </summary>
/// <typeparam name="T">架构上下文类型，必须实现IArchitectureContext接口</typeparam> /// <typeparam name="T">架构上下文类型，必须实现IArchitectureContext接口</typeparam>
/// <returns>指定类型的架构上下文实例</returns> /// <returns>指定类型的架构上下文实例</returns>
@ -75,7 +73,7 @@ public static class GameContext
} }
/// <summary> /// <summary>
/// 尝试获取指定类型的架构上下文实例 /// 尝试获取指定类型的架构上下文实例
/// </summary> /// </summary>
/// <typeparam name="T">架构上下文类型，必须实现IArchitectureContext接口</typeparam> /// <typeparam name="T">架构上下文类型，必须实现IArchitectureContext接口</typeparam>
/// <param name="context">输出参数，如果找到则返回对应的架构上下文实例，否则返回null</param> /// <param name="context">输出参数，如果找到则返回对应的架构上下文实例，否则返回null</param>
@ -94,7 +92,7 @@ public static class GameContext
} }
/// <summary> /// <summary>
/// 移除指定类型的架构上下文绑定 /// 移除指定类型的架构上下文绑定
/// </summary> /// </summary>
/// <param name="architectureType">要移除的架构类型</param> /// <param name="architectureType">要移除的架构类型</param>
public static void Unbind(Type architectureType) public static void Unbind(Type architectureType)
@ -104,7 +102,7 @@ public static class GameContext
/// <summary> /// <summary>
/// 清空所有架构上下文绑定 /// 清空所有架构上下文绑定
/// </summary> /// </summary>
public static void Clear() public static void Clear()
{ {

6
GFramework.Core/command/CommandBus.cs
View File

@ -3,12 +3,12 @@
namespace GFramework.Core.command; namespace GFramework.Core.command;
/// <summary> /// <summary>
/// 命令总线实现类，用于发送和执行命令 /// 命令总线实现类，用于发送和执行命令
/// </summary> /// </summary>
public sealed class CommandBus : ICommandBus public sealed class CommandBus : ICommandBus
{ {
/// <summary> /// <summary>
/// 发送并执行无返回值的命令 /// 发送并执行无返回值的命令
/// </summary> /// </summary>
/// <param name="command">要执行的命令对象，不能为空</param> /// <param name="command">要执行的命令对象，不能为空</param>
/// <exception cref="ArgumentNullException">当command参数为null时抛出</exception> /// <exception cref="ArgumentNullException">当command参数为null时抛出</exception>
@ -20,7 +20,7 @@ public sealed class CommandBus : ICommandBus
} }
/// <summary> /// <summary>
/// 发送并执行有返回值的命令 /// 发送并执行有返回值的命令
/// </summary> /// </summary>
/// <typeparam name="TResult">命令执行结果的类型</typeparam> /// <typeparam name="TResult">命令执行结果的类型</typeparam>
/// <param name="command">要执行的命令对象，不能为空</param> /// <param name="command">要执行的命令对象，不能为空</param>

6
GFramework.Core/environment/DefaultEnvironment.cs
View File

@ -1,17 +1,17 @@
namespace GFramework.Core.environment; namespace GFramework.Core.environment;
/// <summary> /// <summary>
/// 默认环境实现类，继承自EnvironmentBase /// 默认环境实现类，继承自EnvironmentBase
/// </summary> /// </summary>
public class DefaultEnvironment : EnvironmentBase public class DefaultEnvironment : EnvironmentBase
{ {
/// <summary> /// <summary>
/// 获取环境名称 /// 获取环境名称
/// </summary> /// </summary>
public override string Name { get; } = "Default"; public override string Name { get; } = "Default";
/// <summary> /// <summary>
/// 初始化环境 /// 初始化环境
/// </summary> /// </summary>
public override void Initialize() public override void Initialize()
{ {

14
GFramework.Core/environment/EnvironmentBase.cs
View File

@ -4,22 +4,22 @@ using GFramework.Core.rule;
namespace GFramework.Core.environment; namespace GFramework.Core.environment;
/// <summary> /// <summary>
/// 环境基础抽象类，实现了IEnvironment接口，提供环境值的存储和获取功能 /// 环境基础抽象类，实现了IEnvironment接口，提供环境值的存储和获取功能
/// </summary> /// </summary>
public abstract class EnvironmentBase : ContextAwareBase, IEnvironment public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
{ {
/// <summary> /// <summary>
/// 存储环境值的字典，键为字符串，值为对象类型 /// 存储环境值的字典，键为字符串，值为对象类型
/// </summary> /// </summary>
protected readonly Dictionary<string, object> Values = new(); protected readonly Dictionary<string, object> Values = new();
/// <summary> /// <summary>
/// 获取环境名称的抽象属性 /// 获取环境名称的抽象属性
/// </summary> /// </summary>
public abstract string Name { get; } public abstract string Name { get; }
/// <summary> /// <summary>
/// 根据键获取指定类型的值 /// 根据键获取指定类型的值
/// </summary> /// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam> /// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找值的键</param> /// <param name="key">用于查找值的键</param>
@ -30,7 +30,7 @@ public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
} }
/// <summary> /// <summary>
/// 尝试根据键获取指定类型的值 /// 尝试根据键获取指定类型的值
/// </summary> /// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam> /// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找值的键</param> /// <param name="key">用于查找值的键</param>
@ -49,7 +49,7 @@ public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
} }
/// <summary> /// <summary>
/// 根据键获取必需的指定类型值，如果找不到则抛出异常 /// 根据键获取必需的指定类型值，如果找不到则抛出异常
/// </summary> /// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam> /// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找值的键</param> /// <param name="key">用于查找值的键</param>
@ -72,7 +72,7 @@ public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
public abstract void Initialize(); public abstract void Initialize();
/// <summary> /// <summary>
/// 注册键值对到环境值字典中 /// 注册键值对到环境值字典中
/// </summary> /// </summary>
/// <param name="key">要注册的键</param> /// <param name="key">要注册的键</param>
/// <param name="value">要注册的值</param> /// <param name="value">要注册的值</param>

26
GFramework.Core/extensions/ContextAwareExtensions.cs
View File

@ -10,12 +10,12 @@ using GFramework.Core.Abstractions.utility;
namespace GFramework.Core.extensions; namespace GFramework.Core.extensions;
/// <summary> /// <summary>
/// 提供对 IContextAware 接口的扩展方法 /// 提供对 IContextAware 接口的扩展方法
/// </summary> /// </summary>
public static class ContextAwareExtensions public static class ContextAwareExtensions
{ {
/// <summary> /// <summary>
/// 获取架构上下文中的指定系统 /// 获取架构上下文中的指定系统
/// </summary> /// </summary>
/// <typeparam name="TSystem">目标系统类型</typeparam> /// <typeparam name="TSystem">目标系统类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -29,7 +29,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 获取架构上下文中的指定模型 /// 获取架构上下文中的指定模型
/// </summary> /// </summary>
/// <typeparam name="TModel">目标模型类型</typeparam> /// <typeparam name="TModel">目标模型类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -43,7 +43,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 获取架构上下文中的指定工具 /// 获取架构上下文中的指定工具
/// </summary> /// </summary>
/// <typeparam name="TUtility">目标工具类型</typeparam> /// <typeparam name="TUtility">目标工具类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -57,7 +57,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 发送一个查询请求 /// 发送一个查询请求
/// </summary> /// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam> /// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -74,7 +74,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 发送一个无返回结果的命令 /// 发送一个无返回结果的命令
/// </summary> /// </summary>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param> /// <param name="command">要发送的命令</param>
@ -89,7 +89,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 发送一个带返回值的命令 /// 发送一个带返回值的命令
/// </summary> /// </summary>
/// <typeparam name="TResult">命令执行结果类型</typeparam> /// <typeparam name="TResult">命令执行结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -106,7 +106,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 发送一个事件 /// 发送一个事件
/// </summary> /// </summary>
/// <typeparam name="TEvent">事件类型</typeparam> /// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -119,7 +119,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 发送一个具体的事件实例 /// 发送一个具体的事件实例
/// </summary> /// </summary>
/// <typeparam name="TEvent">事件类型</typeparam> /// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -135,7 +135,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 注册事件处理器 /// 注册事件处理器
/// </summary> /// </summary>
/// <typeparam name="TEvent">事件类型</typeparam> /// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -151,7 +151,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 取消对某类型事件的监听 /// 取消对某类型事件的监听
/// </summary> /// </summary>
/// <typeparam name="TEvent">事件类型</typeparam> /// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param> /// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -168,7 +168,7 @@ public static class ContextAwareExtensions
/// <summary> /// <summary>
/// 获取指定类型的环境对象 /// 获取指定类型的环境对象
/// </summary> /// </summary>
/// <typeparam name="T">要获取的环境对象类型</typeparam> /// <typeparam name="T">要获取的环境对象类型</typeparam>
/// <param name="contextAware">上下文感知对象</param> /// <param name="contextAware">上下文感知对象</param>
@ -182,7 +182,7 @@ public static class ContextAwareExtensions
} }
/// <summary> /// <summary>
/// 获取环境对象 /// 获取环境对象
/// </summary> /// </summary>
/// <param name="contextAware">上下文感知对象</param> /// <param name="contextAware">上下文感知对象</param>
/// <returns>环境对象</returns> /// <returns>环境对象</returns>

52
GFramework.Core/extensions/ObjectExtensions.cs
View File

@ -1,20 +1,20 @@
namespace GFramework.Core.extensions; namespace GFramework.Core.extensions;
/// <summary> /// <summary>
/// 提供基于运行时类型判断的对象扩展方法， /// 提供基于运行时类型判断的对象扩展方法，
/// 用于简化类型分支、链式调用和架构分派逻辑。 /// 用于简化类型分支、链式调用和架构分派逻辑。
/// </summary> /// </summary>
public static class ObjectExtensions public static class ObjectExtensions
{ {
/// <summary> /// <summary>
/// 当对象是指定类型 <typeparamref name="T"/> 时，执行给定的操作。 /// 当对象是指定类型 <typeparamref name="T" /> 时，执行给定的操作。
/// </summary> /// </summary>
/// <typeparam name="T">目标类型</typeparam> /// <typeparam name="T">目标类型</typeparam>
/// <param name="obj">源对象</param> /// <param name="obj">源对象</param>
/// <param name="action">当对象类型匹配时执行的操作</param> /// <param name="action">当对象类型匹配时执行的操作</param>
/// <returns>如果类型匹配并执行了操作则返回 true，否则返回 false</returns> /// <returns>如果类型匹配并执行了操作则返回 true，否则返回 false</returns>
/// <example> /// <example>
/// <code> /// <code>
/// object obj = new MyRule(); /// object obj = new MyRule();
/// ///
/// bool executed = obj.IfType&lt;MyRule&gt;(rule => /// bool executed = obj.IfType&lt;MyRule&gt;(rule =>
@ -31,18 +31,18 @@ public static class ObjectExtensions
} }
/// <summary> /// <summary>
/// 当对象是指定类型 <typeparamref name="T"/> 时， /// 当对象是指定类型 <typeparamref name="T" /> 时，
/// 使用给定函数计算并返回结果；否则返回默认值。 /// 使用给定函数计算并返回结果；否则返回默认值。
/// </summary> /// </summary>
/// <typeparam name="T">目标类型</typeparam> /// <typeparam name="T">目标类型</typeparam>
/// <typeparam name="TResult">返回结果类型</typeparam> /// <typeparam name="TResult">返回结果类型</typeparam>
/// <param name="obj">源对象</param> /// <param name="obj">源对象</param>
/// <param name="func">当类型匹配时执行的函数</param> /// <param name="func">当类型匹配时执行的函数</param>
/// <returns> /// <returns>
/// 类型匹配时返回函数计算结果，否则返回 <c>default</c> /// 类型匹配时返回函数计算结果，否则返回 <c>default</c>
/// </returns> /// </returns>
/// <example> /// <example>
/// <code> /// <code>
/// object obj = new MyRule { Name = "TestRule" }; /// object obj = new MyRule { Name = "TestRule" };
/// ///
/// string? name = obj.IfType&lt;MyRule, string&gt;(r => r.Name); /// string? name = obj.IfType&lt;MyRule, string&gt;(r => r.Name);
@ -58,15 +58,15 @@ public static class ObjectExtensions
} }
/// <summary> /// <summary>
/// 根据对象是否为指定类型 <typeparamref name="T"/>， /// 根据对象是否为指定类型 <typeparamref name="T" />，
/// 分别执行匹配或不匹配的操作。 /// 分别执行匹配或不匹配的操作。
/// </summary> /// </summary>
/// <typeparam name="T">目标类型</typeparam> /// <typeparam name="T">目标类型</typeparam>
/// <param name="obj">源对象</param> /// <param name="obj">源对象</param>
/// <param name="whenMatch">当对象类型匹配时执行的操作</param> /// <param name="whenMatch">当对象类型匹配时执行的操作</param>
/// <param name="whenNotMatch">当对象类型不匹配时执行的操作</param> /// <param name="whenNotMatch">当对象类型不匹配时执行的操作</param>
/// <example> /// <example>
/// <code> /// <code>
/// obj.IfType&lt;IRule&gt;( /// obj.IfType&lt;IRule&gt;(
/// rule => rule.Execute(), /// rule => rule.Execute(),
/// other => Logger.Warn($"Unsupported type: {other.GetType()}") /// other => Logger.Warn($"Unsupported type: {other.GetType()}")
@ -87,8 +87,8 @@ public static class ObjectExtensions
} }
/// <summary> /// <summary>
/// 当对象是指定类型 <typeparamref name="T"/> 且满足给定条件时， /// 当对象是指定类型 <typeparamref name="T" /> 且满足给定条件时，
/// 执行指定操作。 /// 执行指定操作。
/// </summary> /// </summary>
/// <typeparam name="T">目标类型</typeparam> /// <typeparam name="T">目标类型</typeparam>
/// <param name="obj">源对象</param> /// <param name="obj">源对象</param>
@ -96,7 +96,7 @@ public static class ObjectExtensions
/// <param name="action">当条件满足时执行的操作</param> /// <param name="action">当条件满足时执行的操作</param>
/// <returns>如果类型和条件均匹配并执行了操作则返回 true，否则返回 false</returns> /// <returns>如果类型和条件均匹配并执行了操作则返回 true，否则返回 false</returns>
/// <example> /// <example>
/// <code> /// <code>
/// obj.IfType&lt;MyRule&gt;( /// obj.IfType&lt;MyRule&gt;(
/// r => r.Enabled, /// r => r.Enabled,
/// r => r.Execute() /// r => r.Execute()
@ -118,32 +118,34 @@ public static class ObjectExtensions
} }
/// <summary> /// <summary>
/// 尝试将对象转换为指定的引用类型 <typeparamref name="T"/>。 /// 尝试将对象转换为指定的引用类型 <typeparamref name="T" />。
/// </summary> /// </summary>
/// <typeparam name="T">目标引用类型</typeparam> /// <typeparam name="T">目标引用类型</typeparam>
/// <param name="obj">源对象</param> /// <param name="obj">源对象</param>
/// <returns> /// <returns>
/// 如果类型匹配则返回转换后的对象，否则返回 <c>null</c> /// 如果类型匹配则返回转换后的对象，否则返回 <c>null</c>
/// </returns> /// </returns>
/// <example> /// <example>
/// <code> /// <code>
/// obj.As&lt;MyRule&gt;() /// obj.As&lt;MyRule&gt;()
/// ?.Execute(); /// ?.Execute();
/// </code> /// </code>
/// </example> /// </example>
public static T? As<T>(this object obj) where T : class public static T? As<T>(this object obj) where T : class
=> obj as T; {
return obj as T;
}
/// <summary> /// <summary>
/// 对对象执行指定操作后返回对象本身， /// 对对象执行指定操作后返回对象本身，
/// 用于构建流式（链式）调用。 /// 用于构建流式（链式）调用。
/// </summary> /// </summary>
/// <typeparam name="T">对象类型</typeparam> /// <typeparam name="T">对象类型</typeparam>
/// <param name="obj">源对象</param> /// <param name="obj">源对象</param>
/// <param name="action">要执行的操作</param> /// <param name="action">要执行的操作</param>
/// <returns>原对象</returns> /// <returns>原对象</returns>
/// <example> /// <example>
/// <code> /// <code>
/// obj.As&lt;MyRule&gt;() /// obj.As&lt;MyRule&gt;()
/// ?.Do(r => r.Initialize()) /// ?.Do(r => r.Initialize())
/// ?.Do(r => r.Execute()); /// ?.Do(r => r.Execute());
@ -156,15 +158,15 @@ public static class ObjectExtensions
} }
/// <summary> /// <summary>
/// 根据对象的运行时类型，依次匹配并执行对应的处理逻辑， /// 根据对象的运行时类型，依次匹配并执行对应的处理逻辑，
/// 只会执行第一个匹配成功的处理器。 /// 只会执行第一个匹配成功的处理器。
/// </summary> /// </summary>
/// <param name="obj">源对象</param> /// <param name="obj">源对象</param>
/// <param name="handlers"> /// <param name="handlers">
/// 类型与处理操作的元组数组，用于定义类型分派规则 /// 类型与处理操作的元组数组，用于定义类型分派规则
/// </param> /// </param>
/// <example> /// <example>
/// <code> /// <code>
/// obj.SwitchType( /// obj.SwitchType(
/// (typeof(IRule), o => HandleRule((IRule)o)), /// (typeof(IRule), o => HandleRule((IRule)o)),
/// (typeof(ISystem), o => HandleSystem((ISystem)o)) /// (typeof(ISystem), o => HandleSystem((ISystem)o))

5
GFramework.Core/ioc/IocContainer.cs
View File

@ -114,10 +114,7 @@ public class IocContainer : ContextAwareBase, IIocContainer
RegisterInternal(concreteType, instance); RegisterInternal(concreteType, instance);
// 注册所有接口类型 // 注册所有接口类型
foreach (var itf in interfaces) foreach (var itf in interfaces) RegisterInternal(itf, instance);
{
RegisterInternal(itf, instance);
}
} }
finally finally
{ {

10
GFramework.Core/logging/ConsoleLoggerFactoryProvider.cs
View File

@ -3,20 +3,22 @@
namespace GFramework.Core.logging; namespace GFramework.Core.logging;
/// <summary> /// <summary>
/// 控制台日志记录器工厂提供程序，用于创建控制台日志记录器实例 /// 控制台日志记录器工厂提供程序，用于创建控制台日志记录器实例
/// </summary> /// </summary>
public sealed class ConsoleLoggerFactoryProvider : ILoggerFactoryProvider public sealed class ConsoleLoggerFactoryProvider : ILoggerFactoryProvider
{ {
/// <summary> /// <summary>
/// 获取或设置日志记录器的最小日志级别，低于此级别的日志将被忽略 /// 获取或设置日志记录器的最小日志级别，低于此级别的日志将被忽略
/// </summary> /// </summary>
public LogLevel MinLevel { get; set; } = LogLevel.Info; public LogLevel MinLevel { get; set; } = LogLevel.Info;
/// <summary> /// <summary>
/// 创建一个日志记录器实例 /// 创建一个日志记录器实例
/// </summary> /// </summary>
/// <param name="name">日志记录器的名称，用于标识特定的日志源</param> /// <param name="name">日志记录器的名称，用于标识特定的日志源</param>
/// <returns>配置了指定名称和最小日志级别的ILogger实例</returns> /// <returns>配置了指定名称和最小日志级别的ILogger实例</returns>
public ILogger CreateLogger(string name) public ILogger CreateLogger(string name)
=> new ConsoleLoggerFactory().GetLogger(name, MinLevel); {
return new ConsoleLoggerFactory().GetLogger(name, MinLevel);
}
} }

10
GFramework.Core/logging/LoggerFactoryResolver.cs
View File

@ -3,24 +3,24 @@
namespace GFramework.Core.logging; namespace GFramework.Core.logging;
/// <summary> /// <summary>
/// 日志工厂提供程序解析器，用于管理和提供日志工厂提供程序实例 /// 日志工厂提供程序解析器，用于管理和提供日志工厂提供程序实例
/// </summary> /// </summary>
public static class LoggerFactoryResolver public static class LoggerFactoryResolver
{ {
/// <summary> /// <summary>
/// 获取或设置当前的日志工厂提供程序 /// 获取或设置当前的日志工厂提供程序
/// </summary> /// </summary>
/// <value> /// <value>
/// 日志工厂提供程序实例，默认为控制台日志工厂提供程序 /// 日志工厂提供程序实例，默认为控制台日志工厂提供程序
/// </value> /// </value>
public static ILoggerFactoryProvider Provider { get; set; } public static ILoggerFactoryProvider Provider { get; set; }
= new ConsoleLoggerFactoryProvider(); = new ConsoleLoggerFactoryProvider();
/// <summary> /// <summary>
/// 获取或设置日志记录的最小级别 /// 获取或设置日志记录的最小级别
/// </summary> /// </summary>
/// <value> /// <value>
/// 日志级别枚举值，默认为Info级别 /// 日志级别枚举值，默认为Info级别
/// </value> /// </value>
public static LogLevel MinLevel { get; set; } = LogLevel.Info; public static LogLevel MinLevel { get; set; } = LogLevel.Info;
} }

2
GFramework.Core/property/BindablePropertyUnRegister.cs
View File

@ -28,10 +28,8 @@ public class BindablePropertyUnRegister<T>(BindableProperty<T> bindableProperty,
{ {
// 检查两个引用都不为null时才执行注销操作 // 检查两个引用都不为null时才执行注销操作
if (BindableProperty != null && OnValueChanged != null) if (BindableProperty != null && OnValueChanged != null)
{
// 调用可绑定属性的注销方法，传入值变化回调函数 // 调用可绑定属性的注销方法，传入值变化回调函数
BindableProperty.UnRegister(OnValueChanged); BindableProperty.UnRegister(OnValueChanged);
}
// 清理属性引用 // 清理属性引用
BindableProperty = null; BindableProperty = null;

4
GFramework.Core/query/QueryBus.cs
View File

@ -3,12 +3,12 @@
namespace GFramework.Core.query; namespace GFramework.Core.query;
/// <summary> /// <summary>
/// 查询总线实现，负责执行查询并返回结果 /// 查询总线实现，负责执行查询并返回结果
/// </summary> /// </summary>
public sealed class QueryBus : IQueryBus public sealed class QueryBus : IQueryBus
{ {
/// <summary> /// <summary>
/// 执行指定的查询并返回结果 /// 执行指定的查询并返回结果
/// </summary> /// </summary>
/// <typeparam name="TResult">查询结果的类型</typeparam> /// <typeparam name="TResult">查询结果的类型</typeparam>
/// <param name="query">要执行的查询对象</param> /// <param name="query">要执行的查询对象</param>

75
GFramework.Game.Abstractions/assets/AssetCatalog.cs
View File

@ -1,46 +1,45 @@
namespace GFramework.Game.Abstractions.assets namespace GFramework.Game.Abstractions.assets;
/// <summary>
/// 资源目录类，用于定义和管理游戏中的场景和资源标识符
/// </summary>
public static class AssetCatalog
{ {
/// <summary> /// <summary>
/// 资源目录类，用于定义和管理游戏中的场景和资源标识符 /// 资源标识符接口，定义了资源路径的访问接口
/// </summary> /// </summary>
public static class AssetCatalog public interface IAssetId
{ {
/// <summary> /// <summary>
/// 资源标识符接口，定义了资源路径的访问接口 /// 获取资源的路径
/// </summary> /// </summary>
public interface IAssetId string Path { get; }
{
/// <summary>
/// 获取资源的路径
/// </summary>
string Path { get; }
}
/// <summary>
/// 资源目录映射结构体，用于存储资源目录的键值对映射关系
/// </summary>
/// <param name="Key">资源目录的键</param>
/// <param name="Id">资源标识符</param>
public readonly record struct AssetCatalogMapping(string Key, IAssetId Id);
/// <summary>
/// 场景页面资源标识符结构体，用于标识场景页面资源
/// </summary>
/// <param name="Path">场景页面资源路径</param>
public readonly record struct ScenePageId(string Path) : IAssetId;
/// <summary>
/// 场景单元资源标识符结构体，用于标识场景单元资源
/// </summary>
/// <param name="Path">场景单元资源路径</param>
public readonly record struct SceneUnitId(string Path) : IAssetId;
/// <summary>
/// 通用资源标识符结构体，实现IAssetId接口
/// </summary>
/// <param name="Path">资源路径</param>
public readonly record struct AssetId(string Path) : IAssetId;
} }
/// <summary>
/// 资源目录映射结构体，用于存储资源目录的键值对映射关系
/// </summary>
/// <param name="Key">资源目录的键</param>
/// <param name="Id">资源标识符</param>
public readonly record struct AssetCatalogMapping(string Key, IAssetId Id);
/// <summary>
/// 场景页面资源标识符结构体，用于标识场景页面资源
/// </summary>
/// <param name="Path">场景页面资源路径</param>
public readonly record struct ScenePageId(string Path) : IAssetId;
/// <summary>
/// 场景单元资源标识符结构体，用于标识场景单元资源
/// </summary>
/// <param name="Path">场景单元资源路径</param>
public readonly record struct SceneUnitId(string Path) : IAssetId;
/// <summary>
/// 通用资源标识符结构体，实现IAssetId接口
/// </summary>
/// <param name="Path">资源路径</param>
public readonly record struct AssetId(string Path) : IAssetId;
} }

7
GFramework.Game.Abstractions/internals/IsExternalInit.cs
View File

@ -3,10 +3,9 @@
// when targeting netstandard2.0 or older frameworks. // when targeting netstandard2.0 or older frameworks.
#pragma warning disable S2094 // Remove this empty class #pragma warning disable S2094 // Remove this empty class
namespace System.Runtime.CompilerServices namespace System.Runtime.CompilerServices;
internal static class IsExternalInit
{ {
internal static class IsExternalInit
{
}
} }
#pragma warning restore S2094 #pragma warning restore S2094

8
GFramework.Game/architecture/AbstractModule.cs
View File

@ -4,12 +4,12 @@ using GFramework.Core.Abstractions.enums;
namespace GFramework.Game.architecture; namespace GFramework.Game.architecture;
/// <summary> /// <summary>
/// 抽象模块类，实现IArchitectureModule接口，为架构模块提供基础功能 /// 抽象模块类，实现IArchitectureModule接口，为架构模块提供基础功能
/// </summary> /// </summary>
public abstract class AbstractModule : IArchitectureModule public abstract class AbstractModule : IArchitectureModule
{ {
/// <summary> /// <summary>
/// 在指定架构阶段执行的操作 /// 在指定架构阶段执行的操作
/// </summary> /// </summary>
/// <param name="phase">架构阶段枚举值</param> /// <param name="phase">架构阶段枚举值</param>
/// <param name="architecture">架构实例</param> /// <param name="architecture">架构实例</param>
@ -18,7 +18,7 @@ public abstract class AbstractModule : IArchitectureModule
} }
/// <summary> /// <summary>
/// 在架构阶段执行的操作 /// 在架构阶段执行的操作
/// </summary> /// </summary>
/// <param name="phase">架构阶段枚举值</param> /// <param name="phase">架构阶段枚举值</param>
public virtual void OnArchitecturePhase(ArchitecturePhase phase) public virtual void OnArchitecturePhase(ArchitecturePhase phase)
@ -26,7 +26,7 @@ public abstract class AbstractModule : IArchitectureModule
} }
/// <summary> /// <summary>
/// 安装模块到架构中 /// 安装模块到架构中
/// </summary> /// </summary>
/// <param name="architecture">要安装到的架构实例</param> /// <param name="architecture">要安装到的架构实例</param>
public abstract void Install(IArchitecture architecture); public abstract void Install(IArchitecture architecture);

2
GFramework.Godot.SourceGenerators.Abstractions/GodotModuleMarker.cs
View File

@ -1,6 +1,6 @@
namespace GFramework.Godot.SourceGenerators.Abstractions; namespace GFramework.Godot.SourceGenerators.Abstractions;
/// <summary> /// <summary>
/// Godot 模块命名空间占位类型 /// Godot 模块命名空间占位类型
/// </summary> /// </summary>
internal sealed class GodotModuleMarker; internal sealed class GodotModuleMarker;

5
GFramework.Godot/architecture/AbstractArchitecture.cs
View File

@ -1,7 +1,4 @@
using System; using GFramework.Core.Abstractions.architecture;
using System.Collections.Generic;
using System.Threading.Tasks;
using GFramework.Core.Abstractions.architecture;
using GFramework.Core.Abstractions.environment; using GFramework.Core.Abstractions.environment;
using GFramework.Core.architecture; using GFramework.Core.architecture;
using GFramework.Core.constants; using GFramework.Core.constants;

3
GFramework.Godot/architecture/ArchitectureAnchor.cs
View File

@ -1,5 +1,4 @@
using System; using Godot;
using Godot;
namespace GFramework.Godot.architecture; namespace GFramework.Godot.architecture;

1
GFramework.Godot/assets/AbstractResourceFactorySystem.cs
View File

@ -1,4 +1,3 @@
using System;
using GFramework.Core.Abstractions.enums; using GFramework.Core.Abstractions.enums;
using GFramework.Core.extensions; using GFramework.Core.extensions;
using GFramework.Core.system; using GFramework.Core.system;

4
GFramework.Godot/assets/IResourceLoadSystem.cs
View File

@ -1,6 +1,4 @@
using System; using GFramework.Core.Abstractions.system;
using System.Collections.Generic;
using GFramework.Core.Abstractions.system;
using GFramework.Game.Abstractions.assets; using GFramework.Game.Abstractions.assets;
using Godot; using Godot;

3
GFramework.Godot/assets/ResourceLoadSystem.cs
View File

@ -1,5 +1,4 @@
using System.Collections.Generic; using GFramework.Core.system;
using GFramework.Core.system;
using GFramework.Game.Abstractions.assets; using GFramework.Game.Abstractions.assets;
using Godot; using Godot;

15
GFramework.Godot/extensions/signal/SignalBuilder.cs
View File

@ -3,7 +3,7 @@
namespace GFramework.Godot.extensions.signal; namespace GFramework.Godot.extensions.signal;
/// <summary> /// <summary>
/// 信号连接构建器，用于以流畅的方式连接Godot信号 /// 信号连接构建器，用于以流畅的方式连接Godot信号
/// </summary> /// </summary>
/// <param name="target">要连接信号的目标节点</param> /// <param name="target">要连接信号的目标节点</param>
/// <param name="signal">要连接的信号名称</param> /// <param name="signal">要连接的信号名称</param>
@ -12,7 +12,7 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
private GodotObject.ConnectFlags? _flags; private GodotObject.ConnectFlags? _flags;
/// <summary> /// <summary>
/// 设置连接标志 /// 设置连接标志
/// </summary> /// </summary>
/// <param name="flags">连接标志</param> /// <param name="flags">连接标志</param>
/// <returns>当前构建器实例</returns> /// <returns>当前构建器实例</returns>
@ -23,7 +23,7 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
} }
/// <summary> /// <summary>
/// 连接信号到指定的可调用对象 /// 连接信号到指定的可调用对象
/// </summary> /// </summary>
/// <param name="callable">要连接的可调用对象</param> /// <param name="callable">要连接的可调用对象</param>
/// <param name="flags">连接标志</param> /// <param name="flags">连接标志</param>
@ -41,7 +41,7 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
} }
/// <summary> /// <summary>
/// 连接信号到指定的可调用对象并立即调用 /// 连接信号到指定的可调用对象并立即调用
/// </summary> /// </summary>
/// <param name="callable">要连接的可调用对象</param> /// <param name="callable">要连接的可调用对象</param>
/// <param name="flags">连接标志</param> /// <param name="flags">连接标志</param>
@ -55,8 +55,11 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
} }
/// <summary> /// <summary>
/// 显式结束，返回 Node /// 显式结束，返回 Node
/// </summary> /// </summary>
/// <returns>目标节点</returns> /// <returns>目标节点</returns>
public GodotObject End() => target; public GodotObject End()
{
return target;
}
} }

8
GFramework.Godot/extensions/signal/SignalFluentExtensions.cs
View File

@ -3,12 +3,12 @@
namespace GFramework.Godot.extensions.signal; namespace GFramework.Godot.extensions.signal;
/// <summary> /// <summary>
/// 为Godot Node节点提供信号相关的流畅API扩展方法 /// 为Godot Node节点提供信号相关的流畅API扩展方法
/// </summary> /// </summary>
public static class SignalFluentExtensions public static class SignalFluentExtensions
{ {
/// <summary> /// <summary>
/// 为指定节点创建信号构建器 /// 为指定节点创建信号构建器
/// </summary> /// </summary>
/// <param name="object">要创建信号构建器的Godot对象</param> /// <param name="object">要创建信号构建器的Godot对象</param>
/// <param name="signal">信号名称</param> /// <param name="signal">信号名称</param>
@ -16,5 +16,7 @@ public static class SignalFluentExtensions
public static SignalBuilder Signal( public static SignalBuilder Signal(
this GodotObject @object, this GodotObject @object,
StringName signal) StringName signal)
=> new(@object, signal); {
return new SignalBuilder(@object, signal);
}
} }

5
GFramework.Godot/logging/GodotLogger.cs
View File

@ -18,10 +18,7 @@ public sealed class GodotLogger(
var logPrefix = $"[{timestamp}] {levelStr} [{Name()}]"; var logPrefix = $"[{timestamp}] {levelStr} [{Name()}]";
// 添加异常信息 // 添加异常信息
if (exception != null) if (exception != null) message += "\n" + exception;
{
message += "\n" + exception;
}
var logMessage = $"{logPrefix} {message}"; var logMessage = $"{logPrefix} {message}";

11
GFramework.Godot/logging/GodotLoggerFactoryProvider.cs
View File

@ -3,19 +3,22 @@
namespace GFramework.Godot.logging; namespace GFramework.Godot.logging;
/// <summary> /// <summary>
/// Godot日志工厂提供程序，用于创建Godot日志记录器实例 /// Godot日志工厂提供程序，用于创建Godot日志记录器实例
/// </summary> /// </summary>
public sealed class GodotLoggerFactoryProvider : ILoggerFactoryProvider public sealed class GodotLoggerFactoryProvider : ILoggerFactoryProvider
{ {
/// <summary> /// <summary>
/// 获取或设置最小日志级别 /// 获取或设置最小日志级别
/// </summary> /// </summary>
public LogLevel MinLevel { get; set; } public LogLevel MinLevel { get; set; }
/// <summary> /// <summary>
/// 创建指定名称的日志记录器实例 /// 创建指定名称的日志记录器实例
/// </summary> /// </summary>
/// <param name="name">日志记录器的名称</param> /// <param name="name">日志记录器的名称</param>
/// <returns>返回配置了最小日志级别的Godot日志记录器实例</returns> /// <returns>返回配置了最小日志级别的Godot日志记录器实例</returns>
public ILogger CreateLogger(string name) => new GodotLoggerFactory().GetLogger(name, MinLevel); public ILogger CreateLogger(string name)
{
return new GodotLoggerFactory().GetLogger(name, MinLevel);
}
} }

1
GFramework.Godot/system/AbstractAudioManagerSystem.cs
View File

@ -1,4 +1,3 @@
using System.Collections.Generic;
using GFramework.Core.extensions; using GFramework.Core.extensions;
using GFramework.Core.system; using GFramework.Core.system;
using GFramework.Game.Abstractions.assets; using GFramework.Game.Abstractions.assets;

16
GFramework.SourceGenerators.Common/constants/PathContests.cs
View File

@ -1,42 +1,42 @@
namespace GFramework.SourceGenerators.Common.constants; namespace GFramework.SourceGenerators.Common.constants;
/// <summary> /// <summary>
/// 定义GFramework项目中使用的路径常量 /// 定义GFramework项目中使用的路径常量
/// </summary> /// </summary>
public static class PathContests public static class PathContests
{ {
/// <summary> /// <summary>
/// GFramework基础命名空间 /// GFramework基础命名空间
/// </summary> /// </summary>
public const string BaseNamespace = "GFramework"; public const string BaseNamespace = "GFramework";
/// <summary> /// <summary>
/// GFramework核心模块命名空间 /// GFramework核心模块命名空间
/// </summary> /// </summary>
public const string CoreNamespace = $"{BaseNamespace}.Core"; public const string CoreNamespace = $"{BaseNamespace}.Core";
/// <summary> /// <summary>
/// GFramework Godot模块命名空间 /// GFramework Godot模块命名空间
/// </summary> /// </summary>
public const string GodotNamespace = $"{BaseNamespace}.Godot"; public const string GodotNamespace = $"{BaseNamespace}.Godot";
/// <summary> /// <summary>
/// GFramework游戏模块命名空间 /// GFramework游戏模块命名空间
/// </summary> /// </summary>
public const string GameNamespace = $"{BaseNamespace}.Game"; public const string GameNamespace = $"{BaseNamespace}.Game";
/// <summary> /// <summary>
/// GFramework源代码生成器抽象层命名空间 /// GFramework源代码生成器抽象层命名空间
/// </summary> /// </summary>
public const string SourceGeneratorsAbstractionsPath = $"{BaseNamespace}.SourceGenerators.Abstractions"; public const string SourceGeneratorsAbstractionsPath = $"{BaseNamespace}.SourceGenerators.Abstractions";
/// <summary> /// <summary>
/// GFramework Godot源代码生成器抽象层命名空间 /// GFramework Godot源代码生成器抽象层命名空间
/// </summary> /// </summary>
public const string GodotSourceGeneratorsAbstractionsPath = $"{GodotNamespace}.SourceGenerators.Abstractions"; public const string GodotSourceGeneratorsAbstractionsPath = $"{GodotNamespace}.SourceGenerators.Abstractions";
/// <summary> /// <summary>
/// GFramework核心抽象层命名空间 /// GFramework核心抽象层命名空间
/// </summary> /// </summary>
public const string CoreAbstractionsNamespace = $"{CoreNamespace}.Abstractions"; public const string CoreAbstractionsNamespace = $"{CoreNamespace}.Abstractions";
} }

4
GFramework.SourceGenerators.Common/diagnostics/CommonDiagnostics.cs
View File

@ -24,7 +24,7 @@ public static class CommonDiagnostics
"Class '{0}' must be declared partial for code generation", "Class '{0}' must be declared partial for code generation",
"GFramework.Common", "GFramework.Common",
DiagnosticSeverity.Error, DiagnosticSeverity.Error,
isEnabledByDefault: true true
); );
/// <summary> /// <summary>
@ -44,7 +44,7 @@ public static class CommonDiagnostics
"{0}", "{0}",
"GFramework.Trace", "GFramework.Trace",
DiagnosticSeverity.Info, DiagnosticSeverity.Info,
isEnabledByDefault: true true
); );
/// <summary> /// <summary>

8
GFramework.SourceGenerators.Common/generator/AttributeClassGeneratorBase.cs
View File

@ -128,7 +128,9 @@ public abstract class AttributeClassGeneratorBase : IIncrementalGenerator
ClassDeclarationSyntax syntax, ClassDeclarationSyntax syntax,
INamedTypeSymbol symbol, INamedTypeSymbol symbol,
AttributeData attr) AttributeData attr)
=> true; {
return true;
}
/// <summary> /// <summary>
/// 生成源代码 /// 生成源代码
@ -150,7 +152,9 @@ public abstract class AttributeClassGeneratorBase : IIncrementalGenerator
/// <param name="symbol">命名类型符号</param> /// <param name="symbol">命名类型符号</param>
/// <returns>生成文件的提示名称</returns> /// <returns>生成文件的提示名称</returns>
protected virtual string GetHintName(INamedTypeSymbol symbol) protected virtual string GetHintName(INamedTypeSymbol symbol)
=> $"{symbol.Name}.g.cs"; {
return $"{symbol.Name}.g.cs";
}
/// <summary> /// <summary>
/// 报告类必须是部分类的错误 /// 报告类必须是部分类的错误

20
GFramework.SourceGenerators.Common/generator/AttributeEnumGeneratorBase.cs
View File

@ -5,17 +5,17 @@ using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace GFramework.SourceGenerators.Common.generator; namespace GFramework.SourceGenerators.Common.generator;
/// <summary> /// <summary>
/// 属性枚举生成器基类，用于基于特定属性的枚举进行源代码生成 /// 属性枚举生成器基类，用于基于特定属性的枚举进行源代码生成
/// </summary> /// </summary>
public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
{ {
/// <summary> /// <summary>
/// 获取属性的短名称（不包含后缀） /// 获取属性的短名称（不包含后缀）
/// </summary> /// </summary>
protected abstract string AttributeShortNameWithoutSuffix { get; } protected abstract string AttributeShortNameWithoutSuffix { get; }
/// <summary> /// <summary>
/// 初始化增量生成器 /// 初始化增量生成器
/// </summary> /// </summary>
/// <param name="context">增量生成器初始化上下文</param> /// <param name="context">增量生成器初始化上下文</param>
public void Initialize(IncrementalGeneratorInitializationContext context) public void Initialize(IncrementalGeneratorInitializationContext context)
@ -31,7 +31,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
(ctx, _) => (ctx, _) =>
{ {
var syntax = (EnumDeclarationSyntax)ctx.Node; var syntax = (EnumDeclarationSyntax)ctx.Node;
var symbol = ctx.SemanticModel.GetDeclaredSymbol(syntax, cancellationToken: _) as INamedTypeSymbol; var symbol = ctx.SemanticModel.GetDeclaredSymbol(syntax, _) as INamedTypeSymbol;
return (syntax, symbol); return (syntax, symbol);
}) })
.Where(x => x.symbol is not null); .Where(x => x.symbol is not null);
@ -57,7 +57,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
} }
/// <summary> /// <summary>
/// 解析指定符号上的属性数据 /// 解析指定符号上的属性数据
/// </summary> /// </summary>
/// <param name="compilation">编译对象</param> /// <param name="compilation">编译对象</param>
/// <param name="symbol">命名类型符号</param> /// <param name="symbol">命名类型符号</param>
@ -67,7 +67,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
INamedTypeSymbol symbol); INamedTypeSymbol symbol);
/// <summary> /// <summary>
/// 验证符号是否符合生成要求 /// 验证符号是否符合生成要求
/// </summary> /// </summary>
/// <param name="context">源生产上下文</param> /// <param name="context">源生产上下文</param>
/// <param name="compilation">编译对象</param> /// <param name="compilation">编译对象</param>
@ -83,7 +83,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
AttributeData attr); AttributeData attr);
/// <summary> /// <summary>
/// 生成源代码 /// 生成源代码
/// </summary> /// </summary>
/// <param name="symbol">命名类型符号</param> /// <param name="symbol">命名类型符号</param>
/// <param name="attr">属性数据</param> /// <param name="attr">属性数据</param>
@ -93,10 +93,12 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
AttributeData attr); AttributeData attr);
/// <summary> /// <summary>
/// 获取生成文件的提示名称 /// 获取生成文件的提示名称
/// </summary> /// </summary>
/// <param name="symbol">命名类型符号</param> /// <param name="symbol">命名类型符号</param>
/// <returns>生成文件的提示名称</returns> /// <returns>生成文件的提示名称</returns>
protected virtual string GetHintName(INamedTypeSymbol symbol) protected virtual string GetHintName(INamedTypeSymbol symbol)
=> $"{symbol.Name}.g.cs"; {
return $"{symbol.Name}.g.cs";
}
} }

6
GFramework.SourceGenerators.Common/generator/MetadataAttributeClassGeneratorBase.cs
View File

@ -4,18 +4,18 @@ using Microsoft.CodeAnalysis;
namespace GFramework.SourceGenerators.Common.generator; namespace GFramework.SourceGenerators.Common.generator;
/// <summary> /// <summary>
/// 元数据属性类生成器基类，用于基于元数据名称解析特性的抽象基类 /// 元数据属性类生成器基类，用于基于元数据名称解析特性的抽象基类
/// </summary> /// </summary>
public abstract class MetadataAttributeClassGeneratorBase public abstract class MetadataAttributeClassGeneratorBase
: AttributeClassGeneratorBase : AttributeClassGeneratorBase
{ {
/// <summary> /// <summary>
/// 获取特性元数据名称的抽象属性 /// 获取特性元数据名称的抽象属性
/// </summary> /// </summary>
protected abstract string AttributeMetadataName { get; } protected abstract string AttributeMetadataName { get; }
/// <summary> /// <summary>
/// 根据元数据名称解析指定符号上的特性 /// 根据元数据名称解析指定符号上的特性
/// </summary> /// </summary>
/// <param name="compilation">编译对象，用于获取类型信息</param> /// <param name="compilation">编译对象，用于获取类型信息</param>
/// <param name="symbol">命名类型符号，用于查找其上的特性</param> /// <param name="symbol">命名类型符号，用于查找其上的特性</param>

6
GFramework.SourceGenerators.Common/generator/TypeAttributeClassGeneratorBase.cs
View File

@ -5,18 +5,18 @@ using Microsoft.CodeAnalysis;
namespace GFramework.SourceGenerators.Common.generator; namespace GFramework.SourceGenerators.Common.generator;
/// <summary> /// <summary>
/// 基于类型特性的类生成器基类 /// 基于类型特性的类生成器基类
/// </summary> /// </summary>
public abstract class TypeAttributeClassGeneratorBase public abstract class TypeAttributeClassGeneratorBase
: AttributeClassGeneratorBase : AttributeClassGeneratorBase
{ {
/// <summary> /// <summary>
/// 获取要处理的特性类型 /// 获取要处理的特性类型
/// </summary> /// </summary>
protected abstract Type AttributeType { get; } protected abstract Type AttributeType { get; }
/// <summary> /// <summary>
/// 解析指定符号上的特性 /// 解析指定符号上的特性
/// </summary> /// </summary>
/// <param name="compilation">编译对象（未使用）</param> /// <param name="compilation">编译对象（未使用）</param>
/// <param name="symbol">要检查的命名类型符号</param> /// <param name="symbol">要检查的命名类型符号</param>

10
GFramework.SourceGenerators.Tests/core/GeneratorSnapshotTest.cs
View File

@ -5,14 +5,14 @@ using NUnit.Framework;
namespace GFramework.SourceGenerators.Tests.core; namespace GFramework.SourceGenerators.Tests.core;
/// <summary> /// <summary>
/// 用于测试源代码生成器的快照测试类 /// 用于测试源代码生成器的快照测试类
/// </summary> /// </summary>
/// <typeparam name="TGenerator">要测试的源代码生成器类型</typeparam> /// <typeparam name="TGenerator">要测试的源代码生成器类型</typeparam>
public static class GeneratorSnapshotTest<TGenerator> public static class GeneratorSnapshotTest<TGenerator>
where TGenerator : new() where TGenerator : new()
{ {
/// <summary> /// <summary>
/// 运行源代码生成器的快照测试 /// 运行源代码生成器的快照测试
/// </summary> /// </summary>
/// <param name="source">输入的源代码字符串</param> /// <param name="source">输入的源代码字符串</param>
/// <param name="snapshotFolder">快照文件存储的文件夹路径</param> /// <param name="snapshotFolder">快照文件存储的文件夹路径</param>
@ -61,10 +61,12 @@ public static class GeneratorSnapshotTest<TGenerator>
} }
/// <summary> /// <summary>
/// 标准化文本内容，将换行符统一为\n并去除首尾空白 /// 标准化文本内容，将换行符统一为\n并去除首尾空白
/// </summary> /// </summary>
/// <param name="text">要标准化的文本</param> /// <param name="text">要标准化的文本</param>
/// <returns>标准化后的文本</returns> /// <returns>标准化后的文本</returns>
private static string Normalize(string text) private static string Normalize(string text)
=> text.Replace("\r\n", "\n").Trim(); {
return text.Replace("\r\n", "\n").Trim();
}
} }

10
GFramework.SourceGenerators.Tests/rule/ContextAwareGeneratorSnapshotTests.cs
View File

@ -5,15 +5,15 @@ using NUnit.Framework;
namespace GFramework.SourceGenerators.Tests.rule; namespace GFramework.SourceGenerators.Tests.rule;
/// <summary> /// <summary>
/// 上下文感知生成器快照测试类 /// 上下文感知生成器快照测试类
/// 用于测试ContextAwareGenerator源代码生成器的输出快照 /// 用于测试ContextAwareGenerator源代码生成器的输出快照
/// </summary> /// </summary>
[TestFixture] [TestFixture]
public class ContextAwareGeneratorSnapshotTests public class ContextAwareGeneratorSnapshotTests
{ {
/// <summary> /// <summary>
/// 测试ContextAwareGenerator源代码生成器的快照功能 /// 测试ContextAwareGenerator源代码生成器的快照功能
/// 验证生成器对带有ContextAware特性的类的处理结果 /// 验证生成器对带有ContextAware特性的类的处理结果
/// </summary> /// </summary>
/// <returns>异步任务，无返回值</returns> /// <returns>异步任务，无返回值</returns>
[Test] [Test]
@ -75,7 +75,7 @@ public class ContextAwareGeneratorSnapshotTests
// 执行生成器快照测试，将生成的代码与预期快照进行比较 // 执行生成器快照测试，将生成的代码与预期快照进行比较
await GeneratorSnapshotTest<ContextAwareGenerator>.RunAsync( await GeneratorSnapshotTest<ContextAwareGenerator>.RunAsync(
source, source,
snapshotFolder: Path.Combine( Path.Combine(
TestContext.CurrentContext.TestDirectory, TestContext.CurrentContext.TestDirectory,
"rule", "rule",
"snapshots", "snapshots",

2
GFramework.SourceGenerators/diagnostics/ContextAwareDiagnostic.cs
View File

@ -8,7 +8,7 @@ namespace GFramework.SourceGenerators.diagnostics;
public static class ContextAwareDiagnostic public static class ContextAwareDiagnostic
{ {
/// <summary> /// <summary>
/// 诊断规则：ContextAwareAttribute只能应用于类 /// 诊断规则：ContextAwareAttribute只能应用于类
/// </summary> /// </summary>
public static readonly DiagnosticDescriptor ContextAwareOnlyForClass = new( public static readonly DiagnosticDescriptor ContextAwareOnlyForClass = new(
"GF_Rule_001", "GF_Rule_001",

12
GFramework.SourceGenerators/enums/EnumExtensionsGenerator.cs
View File

@ -9,7 +9,7 @@ using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace GFramework.SourceGenerators.enums; namespace GFramework.SourceGenerators.enums;
/// <summary> /// <summary>
/// 枚举扩展方法生成器，用于自动生成枚举相关的扩展方法 /// 枚举扩展方法生成器，用于自动生成枚举相关的扩展方法
/// </summary> /// </summary>
[Generator] [Generator]
public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
@ -18,7 +18,7 @@ public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
$"{PathContests.SourceGeneratorsAbstractionsPath}.enums.GenerateEnumExtensionsAttribute"; $"{PathContests.SourceGeneratorsAbstractionsPath}.enums.GenerateEnumExtensionsAttribute";
/// <summary> /// <summary>
/// 仅用于 Syntax 粗筛选 /// 仅用于 Syntax 粗筛选
/// </summary> /// </summary>
protected override string AttributeShortNameWithoutSuffix => "GenerateEnumExtensions"; protected override string AttributeShortNameWithoutSuffix => "GenerateEnumExtensions";
@ -49,7 +49,7 @@ public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
} }
/// <summary> /// <summary>
/// 生成枚举扩展方法的源代码 /// 生成枚举扩展方法的源代码
/// </summary> /// </summary>
/// <param name="symbol">枚举类型符号</param> /// <param name="symbol">枚举类型符号</param>
/// <param name="attr">属性数据</param> /// <param name="attr">属性数据</param>
@ -103,10 +103,12 @@ public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
} }
/// <summary> /// <summary>
/// 获取生成文件的提示名称 /// 获取生成文件的提示名称
/// </summary> /// </summary>
/// <param name="symbol">命名类型符号</param> /// <param name="symbol">命名类型符号</param>
/// <returns>生成文件的提示名称</returns> /// <returns>生成文件的提示名称</returns>
protected override string GetHintName(INamedTypeSymbol symbol) protected override string GetHintName(INamedTypeSymbol symbol)
=> $"{symbol.Name}.EnumExtensions.g.cs"; {
return $"{symbol.Name}.EnumExtensions.g.cs";
}
} }

16
GFramework.SourceGenerators/logging/LoggerGenerator.cs
View File

@ -16,18 +16,18 @@ namespace GFramework.SourceGenerators.logging;
public sealed class LoggerGenerator : TypeAttributeClassGeneratorBase public sealed class LoggerGenerator : TypeAttributeClassGeneratorBase
{ {
/// <summary> /// <summary>
/// 获取属性元数据的完整名称，用于标识日志属性的完全限定名 /// 获取属性元数据的完整名称，用于标识日志属性的完全限定名
/// </summary> /// </summary>
protected override Type AttributeType => typeof(LogAttribute); protected override Type AttributeType => typeof(LogAttribute);
/// <summary> /// <summary>
/// 用于语法快速筛选 /// 用于语法快速筛选
/// </summary> /// </summary>
protected override string AttributeShortNameWithoutSuffix => "Log"; protected override string AttributeShortNameWithoutSuffix => "Log";
/// <summary> /// <summary>
/// 对类进行额外语义校验（可选） /// 对类进行额外语义校验（可选）
/// </summary> /// </summary>
protected override bool ValidateSymbol( protected override bool ValidateSymbol(
SourceProductionContext context, SourceProductionContext context,
@ -99,11 +99,15 @@ public sealed class LoggerGenerator : TypeAttributeClassGeneratorBase
} }
/// <summary> /// <summary>
/// 可以自定义生成文件名 /// 可以自定义生成文件名
/// </summary> /// </summary>
protected override string GetHintName(INamedTypeSymbol symbol) protected override string GetHintName(INamedTypeSymbol symbol)
=> $"{symbol.Name}.Logger.g.cs"; {
return $"{symbol.Name}.Logger.g.cs";
}
private static object? GetNamedArg(AttributeData attr, string name) private static object? GetNamedArg(AttributeData attr, string name)
=> attr.NamedArguments.FirstOrDefault(kv => kv.Key == name).Value.Value; {
return attr.NamedArguments.FirstOrDefault(kv => kv.Key == name).Value.Value;
}
} }

26
GFramework.SourceGenerators/rule/ContextAwareGenerator.cs
View File

@ -11,24 +11,24 @@ using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace GFramework.SourceGenerators.rule; namespace GFramework.SourceGenerators.rule;
/// <summary> /// <summary>
/// 上下文感知生成器，用于为标记了ContextAware特性的类自动生成IContextAware接口实现 /// 上下文感知生成器，用于为标记了ContextAware特性的类自动生成IContextAware接口实现
/// </summary> /// </summary>
[Generator] [Generator]
public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
{ {
/// <summary> /// <summary>
/// 获取特性的元数据名称 /// 获取特性的元数据名称
/// </summary> /// </summary>
protected override string AttributeMetadataName => protected override string AttributeMetadataName =>
$"{PathContests.SourceGeneratorsAbstractionsPath}.rule.ContextAwareAttribute"; $"{PathContests.SourceGeneratorsAbstractionsPath}.rule.ContextAwareAttribute";
/// <summary> /// <summary>
/// 获取特性的短名称（不包含后缀） /// 获取特性的短名称（不包含后缀）
/// </summary> /// </summary>
protected override string AttributeShortNameWithoutSuffix => "ContextAware"; protected override string AttributeShortNameWithoutSuffix => "ContextAware";
/// <summary> /// <summary>
/// 验证符号是否符合生成条件 /// 验证符号是否符合生成条件
/// </summary> /// </summary>
/// <param name="context">源生产上下文</param> /// <param name="context">源生产上下文</param>
/// <param name="compilation">编译对象</param> /// <param name="compilation">编译对象</param>
@ -68,7 +68,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
/// <summary> /// <summary>
/// 生成源代码 /// 生成源代码
/// </summary> /// </summary>
/// <param name="context">源生产上下文</param> /// <param name="context">源生产上下文</param>
/// <param name="compilation">编译对象</param> /// <param name="compilation">编译对象</param>
@ -112,18 +112,20 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
} }
/// <summary> /// <summary>
/// 获取生成文件的提示名称 /// 获取生成文件的提示名称
/// </summary> /// </summary>
/// <param name="symbol">命名类型符号</param> /// <param name="symbol">命名类型符号</param>
/// <returns>生成文件的提示名称</returns> /// <returns>生成文件的提示名称</returns>
protected override string GetHintName(INamedTypeSymbol symbol) protected override string GetHintName(INamedTypeSymbol symbol)
=> $"{symbol.Name}.ContextAware.g.cs"; {
return $"{symbol.Name}.ContextAware.g.cs";
}
// ========================= // =========================
// Context 属性（无 global::，与测试一致） // Context 属性（无 global::，与测试一致）
// ========================= // =========================
/// <summary> /// <summary>
/// 生成Context属性 /// 生成Context属性
/// </summary> /// </summary>
/// <param name="sb">字符串构建器</param> /// <param name="sb">字符串构建器</param>
private static void GenerateContextProperty(StringBuilder sb) private static void GenerateContextProperty(StringBuilder sb)
@ -154,7 +156,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
// 显式接口实现（使用 global::） // 显式接口实现（使用 global::）
// ========================= // =========================
/// <summary> /// <summary>
/// 生成接口实现 /// 生成接口实现
/// </summary> /// </summary>
/// <param name="sb">字符串构建器</param> /// <param name="sb">字符串构建器</param>
/// <param name="interfaceSymbol">接口符号</param> /// <param name="interfaceSymbol">接口符号</param>
@ -176,7 +178,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
} }
/// <summary> /// <summary>
/// 生成方法实现 /// 生成方法实现
/// </summary> /// </summary>
/// <param name="sb">字符串构建器</param> /// <param name="sb">字符串构建器</param>
/// <param name="interfaceName">接口名称</param> /// <param name="interfaceName">接口名称</param>
@ -203,7 +205,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
} }
/// <summary> /// <summary>
/// 生成方法体 /// 生成方法体
/// </summary> /// </summary>
/// <param name="sb">字符串构建器</param> /// <param name="sb">字符串构建器</param>
/// <param name="method">方法符号</param> /// <param name="method">方法符号</param>
@ -223,10 +225,8 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
default: default:
if (!method.ReturnsVoid) if (!method.ReturnsVoid)
{
sb.AppendLine( sb.AppendLine(
$" throw new System.NotImplementedException(\"Method '{method.Name}' is not supported.\");"); $" throw new System.NotImplementedException(\"Method '{method.Name}' is not supported.\");");
}
break; break;
} }