gewuyou/GFramework
1
0
Fork 0
mirror of https://github.com/GeWuYou/GFramework.git synced 2026-03-22 02:24: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; }
/// <summary>
/// 获取命令总线
/// 获取命令总线
/// </summary>
public ICommandBus CommandBus { get; }
/// <summary>
/// 获取查询总线
/// 获取查询总线
/// </summary>
public IQueryBus QueryBus { get; }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,6 +1,6 @@
namespace GFramework.Core.Abstractions.query;
/// <summary>
/// 查询输入接口，定义了查询操作的输入规范
/// 查询输入接口，定义了查询操作的输入规范
/// </summary>
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;
/// <summary>
/// 异步测试架构，用于测试异步模型和系统的初始化
/// 异步测试架构，用于测试异步模型和系统的初始化
/// </summary>
public class AsyncTestArchitecture : TestArchitectureBase
{
/// <summary>
/// 异步初始化架构
/// 异步初始化架构
/// </summary>
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;
/// <summary>
/// 同步测试架构类，用于测试架构的生命周期和事件处理
/// 同步测试架构类，用于测试架构的生命周期和事件处理
/// </summary>
public sealed class SyncTestArchitecture : TestArchitectureBase
{
/// <summary>
/// 初始化架构组件，注册模型、系统并设置事件监听器
/// 初始化架构组件，注册模型、系统并设置事件监听器
/// </summary>
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;
/// <summary>
/// 测试架构基类，提供通用的测试架构功能
/// 测试架构基类，提供通用的测试架构功能
/// </summary>
public abstract class TestArchitectureBase : Architecture
{
private Action<TestArchitectureBase>? _postRegistrationHook;
/// <summary>
/// 获取就绪事件是否已触发的状态
/// 获取就绪事件是否已触发的状态
/// </summary>
public bool ReadyEventFired { get; protected set; }
/// <summary>
/// 获取初始化方法是否已调用的状态
/// 获取初始化方法是否已调用的状态
/// </summary>
public bool InitCalled { get; protected set; }
/// <summary>
/// 获取架构阶段历史记录列表
/// 获取架构阶段历史记录列表
/// </summary>
public List<ArchitecturePhase> PhaseHistory { get; } = [];
/// <summary>
/// 添加注册后钩子函数
/// 添加注册后钩子函数
/// </summary>
/// <param name="hook">要添加的钩子函数</param>
public void AddPostRegistrationHook(Action<TestArchitectureBase> hook) => _postRegistrationHook = hook;
public void AddPostRegistrationHook(Action<TestArchitectureBase> hook)
{
_postRegistrationHook = hook;
}
/// <summary>
/// 初始化架构组件，注册模型、系统并设置事件监听器
/// 初始化架构组件，注册模型、系统并设置事件监听器
/// </summary>
protected override void Init()
{
@ -43,7 +46,7 @@ public abstract class TestArchitectureBase : Architecture
}
/// <summary>
/// 进入指定架构阶段时的处理方法，记录阶段历史
/// 进入指定架构阶段时的处理方法，记录阶段历史
/// </summary>
/// <param name="next">要进入的下一个架构阶段</param>
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;
/// <summary>
/// 异步测试模型类，实现了IModel和IAsyncInitializable接口
/// 异步测试模型类，实现了IModel和IAsyncInitializable接口
/// </summary>
public sealed class AsyncTestModel : IModel, IAsyncInitializable
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取模型是否已初始化的标志
/// 获取模型是否已初始化的标志
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// 异步初始化方法，模拟异步初始化过程
/// 异步初始化方法，模拟异步初始化过程
/// </summary>
/// <returns>表示异步操作的Task</returns>
public async Task InitializeAsync()
@ -27,7 +27,7 @@ public sealed class AsyncTestModel : IModel, IAsyncInitializable
}
/// <summary>
/// 同步初始化方法，该方法不应该被调用
/// 同步初始化方法，该方法不应该被调用
/// </summary>
/// <exception cref="InvalidOperationException">当该方法被调用时抛出异常</exception>
public void Init()
@ -37,7 +37,7 @@ public sealed class AsyncTestModel : IModel, IAsyncInitializable
}
/// <summary>
/// 设置架构上下文
/// 设置架构上下文
/// </summary>
/// <param name="context">架构上下文对象</param>
public void SetContext(IArchitectureContext context)
@ -46,13 +46,16 @@ public sealed class AsyncTestModel : IModel, IAsyncInitializable
}
/// <summary>
/// 获取架构上下文
/// 获取架构上下文
/// </summary>
/// <returns>架构上下文对象</returns>
public IArchitectureContext GetContext() => _context;
public IArchitectureContext GetContext()
{
return _context;
}
/// <summary>
/// 处理架构阶段事件
/// 处理架构阶段事件
/// </summary>
/// <param name="phase">架构阶段枚举值</param>
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;
/// <summary>
/// 一个用于测试的失败模型类，实现IModel接口
/// 该模型在初始化时会故意抛出异常，用于测试异常处理机制
/// 一个用于测试的失败模型类，实现IModel接口
/// 该模型在初始化时会故意抛出异常，用于测试异常处理机制
/// </summary>
public sealed class FailingModel : IModel
{
/// <summary>
/// 初始化模型
/// 该方法会故意抛出InvalidOperationException异常
/// 初始化模型
/// 该方法会故意抛出InvalidOperationException异常
/// </summary>
/// <exception cref="InvalidOperationException">总是抛出此异常以模拟初始化失败</exception>
public void Init()
@ -21,8 +21,8 @@ public sealed class FailingModel : IModel
}
/// <summary>
/// 设置架构上下文
/// 该方法为空实现，不执行任何操作
/// 设置架构上下文
/// 该方法为空实现，不执行任何操作
/// </summary>
/// <param name="context">架构上下文对象</param>
public void SetContext(IArchitectureContext context)
@ -30,8 +30,8 @@ public sealed class FailingModel : IModel
}
/// <summary>
/// 获取架构上下文
/// 该方法会抛出NotSupportedException异常
/// 获取架构上下文
/// 该方法会抛出NotSupportedException异常
/// </summary>
/// <returns>不返回任何值，总是抛出异常</returns>
/// <exception cref="NotSupportedException">总是抛出此异常</exception>
@ -41,8 +41,8 @@ public sealed class FailingModel : IModel
}
/// <summary>
/// 处理架构阶段事件
/// 该方法为空实现，不执行任何操作
/// 处理架构阶段事件
/// 该方法为空实现，不执行任何操作
/// </summary>
/// <param name="phase">当前架构阶段</param>
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;
/// <summary>
/// 测试模型类，用于框架测试目的
/// 测试模型类，用于框架测试目的
/// </summary>
public sealed class TestModel : IModel
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取模型是否已初始化的状态
/// 获取模型是否已初始化的状态
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// 初始化模型
/// 初始化模型
/// </summary>
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;
/// <summary>
/// 异步测试系统，实现 ISystem 和 IAsyncInitializable
/// 异步测试系统，实现 ISystem 和 IAsyncInitializable
/// </summary>
public sealed class AsyncTestSystem : ISystem, IAsyncInitializable
{
@ -19,8 +19,15 @@ public sealed class AsyncTestSystem : ISystem, IAsyncInitializable
Initialized = true;
}
public void SetContext(IArchitectureContext context) => _context = context;
public IArchitectureContext GetContext() => _context;
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
public void Init()
{
@ -28,7 +35,10 @@ public sealed class AsyncTestSystem : ISystem, IAsyncInitializable
throw new InvalidOperationException("Sync Init should not be called");
}
public void Destroy() => DestroyCalled = true;
public void Destroy()
{
DestroyCalled = true;
}
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;
/// <summary>
/// 测试系统类，实现了ISystem接口
/// 测试系统类，实现了ISystem接口
/// </summary>
public sealed class TestSystem : ISystem
{
/// <summary>
/// 架构上下文对象
/// 架构上下文对象
/// </summary>
private IArchitectureContext _context = null!;
/// <summary>
/// 获取系统是否已初始化的状态
/// 获取系统是否已初始化的状态
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// 获取系统是否已销毁的状态
/// 获取系统是否已销毁的状态
/// </summary>
public bool DestroyCalled { get; private set; }
/// <summary>
/// 设置架构上下文
/// 设置架构上下文
/// </summary>
/// <param name="context">架构上下文对象</param>
public void SetContext(IArchitectureContext context)
@ -34,7 +34,7 @@ public sealed class TestSystem : ISystem
}
/// <summary>
/// 获取架构上下文
/// 获取架构上下文
/// </summary>
/// <returns>架构上下文对象</returns>
public IArchitectureContext GetContext()
@ -43,7 +43,7 @@ public sealed class TestSystem : ISystem
}
/// <summary>
/// 初始化系统
/// 初始化系统
/// </summary>
public void Init()
{
@ -51,7 +51,7 @@ public sealed class TestSystem : ISystem
}
/// <summary>
/// 销毁系统
/// 销毁系统
/// </summary>
public void Destroy()
{

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

@ -5,7 +5,7 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.tests;
/// <summary>
/// 架构测试基类，封装同步/异步共通测试逻辑
/// 架构测试基类，封装同步/异步共通测试逻辑
/// </summary>
/// <typeparam name="TArchitecture">架构类型，必须继承自Architecture</typeparam>
public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture : Architecture
@ -13,14 +13,14 @@ public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture :
protected TArchitecture? Architecture;
/// <summary>
/// 子类必须实现创建具体架构实例
/// 子类必须实现创建具体架构实例
/// </summary>
/// <returns>创建的架构实例</returns>
protected abstract TArchitecture CreateArchitecture();
/// <summary>
/// 测试设置方法，在每个测试开始前执行
/// 清理游戏上下文并创建架构实例
/// 测试设置方法，在每个测试开始前执行
/// 清理游戏上下文并创建架构实例
/// </summary>
[SetUp]
public void SetUp()
@ -30,8 +30,8 @@ public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture :
}
/// <summary>
/// 测试清理方法，在每个测试结束后执行
/// 销毁架构实例并清理游戏上下文
/// 测试清理方法，在每个测试结束后执行
/// 销毁架构实例并清理游戏上下文
/// </summary>
[TearDown]
public void TearDown()
@ -48,8 +48,8 @@ public abstract class ArchitectureTestsBase<TArchitecture> where TArchitecture :
}
/// <summary>
/// 验证架构初始化失败的断言方法
/// 检查当前架构阶段是否为初始化失败状态
/// 验证架构初始化失败的断言方法
/// 检查当前架构阶段是否为初始化失败状态
/// </summary>
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;
/// <summary>
/// 异步架构测试类，用于测试异步架构的相关功能
/// 异步架构测试类，用于测试异步架构的相关功能
/// </summary>
/// <remarks>
/// 该测试类使用非并行执行模式，确保测试的隔离性
/// 该测试类使用非并行执行模式，确保测试的隔离性
/// </remarks>
[TestFixture]
[NonParallelizable]
public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitecture>
{
/// <summary>
/// 创建异步测试架构实例
/// 创建异步测试架构实例
/// </summary>
/// <returns>AsyncTestArchitecture实例</returns>
protected override AsyncTestArchitecture CreateArchitecture() => new();
protected override AsyncTestArchitecture CreateArchitecture()
{
return new AsyncTestArchitecture();
}
/// <summary>
/// 测试架构是否正确初始化所有组件
/// 测试架构是否正确初始化所有组件
/// </summary>
/// <returns>异步任务</returns>
[Test]
@ -45,7 +48,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
}
/// <summary>
/// 测试架构是否按正确顺序进入各个阶段
/// 测试架构是否按正确顺序进入各个阶段
/// </summary>
/// <returns>异步任务</returns>
[Test]
@ -68,7 +71,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
}
/// <summary>
/// 测试在就绪状态后注册模型是否抛出异常
/// 测试在就绪状态后注册模型是否抛出异常
/// </summary>
/// <returns>异步任务</returns>
[Test]
@ -81,7 +84,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
}
/// <summary>
/// 测试当模型初始化失败时架构是否停止初始化
/// 测试当模型初始化失败时架构是否停止初始化
/// </summary>
/// <returns>异步任务</returns>
[Test]
@ -98,7 +101,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
}
/// <summary>
/// 测试架构销毁是否正确销毁所有系统
/// 测试架构销毁是否正确销毁所有系统
/// </summary>
/// <returns>异步任务</returns>
[Test]
@ -113,7 +116,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
}
/// <summary>
/// 测试InitializeAsync方法是否不会阻塞
/// 测试InitializeAsync方法是否不会阻塞
/// </summary>
/// <returns>异步任务</returns>
[Test]
@ -126,7 +129,7 @@ public class AsyncArchitectureTests : ArchitectureTestsBase<AsyncTestArchitectur
}
/// <summary>
/// 测试InitializeAsync方法是否正确处理异常
/// 测试InitializeAsync方法是否正确处理异常
/// </summary>
/// <returns>异步任务</returns>
[Test]

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

@ -9,17 +9,20 @@ using NUnit.Framework.Legacy;
namespace GFramework.Core.Tests.tests;
/// <summary>
/// 同步架构测试类，用于测试同步架构的初始化、生命周期和组件注册等功能
/// 同步架构测试类，用于测试同步架构的初始化、生命周期和组件注册等功能
/// </summary>
[TestFixture]
[NonParallelizable]
public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
{
protected override SyncTestArchitecture CreateArchitecture() => new();
protected override SyncTestArchitecture CreateArchitecture()
{
return new SyncTestArchitecture();
}
/// <summary>
/// 测试架构是否正确初始化所有组件
/// 验证初始化调用、运行时状态、架构阶段和模型系统注册
/// 测试架构是否正确初始化所有组件
/// 验证初始化调用、运行时状态、架构阶段和模型系统注册
/// </summary>
[Test]
public void Architecture_Should_Initialize_All_Components_Correctly()
@ -46,7 +49,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
}
/// <summary>
/// 测试架构是否按类型正确注册上下文
/// 测试架构是否按类型正确注册上下文
/// </summary>
[Test]
public void Architecture_Should_Register_Context_By_Type()
@ -59,8 +62,8 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
}
/// <summary>
/// 测试架构是否按正确顺序进入各个阶段
/// 验证架构初始化过程中各阶段的执行顺序
/// 测试架构是否按正确顺序进入各个阶段
/// 验证架构初始化过程中各阶段的执行顺序
/// </summary>
[Test]
public void Architecture_Should_Enter_Phases_In_Correct_Order()
@ -83,7 +86,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
}
/// <summary>
/// 测试在架构就绪后注册系统是否抛出异常（当不允许时）
/// 测试在架构就绪后注册系统是否抛出异常（当不允许时）
/// </summary>
[Test]
public void RegisterSystem_AfterReady_Should_Throw_When_NotAllowed()
@ -94,7 +97,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
}
/// <summary>
/// 测试在架构就绪后注册模型是否抛出异常（当不允许时）
/// 测试在架构就绪后注册模型是否抛出异常（当不允许时）
/// </summary>
[Test]
public void RegisterModel_AfterReady_Should_Throw_When_NotAllowed()
@ -105,7 +108,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
}
/// <summary>
/// 测试架构销毁功能，验证销毁后系统被正确销毁且架构进入销毁阶段
/// 测试架构销毁功能，验证销毁后系统被正确销毁且架构进入销毁阶段
/// </summary>
[Test]
public void Architecture_Destroy_Should_Destroy_All_Systems_And_Enter_Destroyed()
@ -121,7 +124,7 @@ public class SyncArchitectureTests : ArchitectureTestsBase<SyncTestArchitecture>
}
/// <summary>
/// 测试当模型初始化失败时架构是否停止初始化
/// 测试当模型初始化失败时架构是否停止初始化
/// </summary>
[Test]
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
{
/// <summary>
/// 获取架构配置对象
/// 获取架构配置对象
/// </summary>
/// <value>
/// 返回一个IArchitectureConfiguration接口的实例，默认为DefaultArchitectureConfiguration类型
/// 返回一个IArchitectureConfiguration接口的实例，默认为DefaultArchitectureConfiguration类型
/// </value>
private IArchitectureConfiguration Configuration { get; } = configuration ?? new ArchitectureConfiguration();
/// <summary>
/// 获取环境配置对象
/// 获取环境配置对象
/// </summary>
/// <value>
/// 返回一个IEnvironment接口的实例，默认为DefaultEnvironment类型
/// 返回一个IEnvironment接口的实例，默认为DefaultEnvironment类型
/// </value>
private IEnvironment Environment { get; } = environment ?? new DefaultEnvironment();
@ -243,13 +243,13 @@ public abstract class Architecture(
#region Component Registration
/// <summary>
/// 同步初始化方法，阻塞当前线程直到初始化完成
/// 同步初始化方法，阻塞当前线程直到初始化完成
/// </summary>
public void Initialize()
{
try
{
InitializeInternalAsync(asyncMode: false).GetAwaiter().GetResult();
InitializeInternalAsync(false).GetAwaiter().GetResult();
}
catch (Exception e)
{
@ -261,14 +261,14 @@ public abstract class Architecture(
}
/// <summary>
/// 异步初始化方法，返回Task以便调用者可以等待初始化完成
/// 异步初始化方法，返回Task以便调用者可以等待初始化完成
/// </summary>
/// <returns>表示异步初始化操作的Task</returns>
public async Task InitializeAsync()
{
try
{
await InitializeInternalAsync(asyncMode: true);
await InitializeInternalAsync(true);
}
catch (Exception e)
{
@ -280,7 +280,7 @@ public abstract class Architecture(
}
/// <summary>
/// 异步初始化组件
/// 异步初始化组件
/// </summary>
/// <param name="component">要初始化的组件对象</param>
/// <param name="asyncMode">是否启用异步模式</param>
@ -289,9 +289,7 @@ public abstract class Architecture(
{
// 根据组件类型和异步模式选择相应的初始化方法
if (asyncMode && component is IAsyncInitializable asyncInit)
{
await asyncInit.InitializeAsync();
}
else
switch (component)
{
@ -305,7 +303,7 @@ public abstract class Architecture(
}
/// <summary>
/// 异步初始化架构内部组件，包括上下文、模型和系统的初始化
/// 异步初始化架构内部组件，包括上下文、模型和系统的初始化
/// </summary>
/// <param name="asyncMode">是否启用异步模式进行组件初始化</param>
/// <returns>异步任务，表示初始化操作的完成</returns>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -4,22 +4,22 @@ using GFramework.Core.rule;
namespace GFramework.Core.environment;
/// <summary>
/// 环境基础抽象类，实现了IEnvironment接口，提供环境值的存储和获取功能
/// 环境基础抽象类，实现了IEnvironment接口，提供环境值的存储和获取功能
/// </summary>
public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
{
/// <summary>
/// 存储环境值的字典，键为字符串，值为对象类型
/// 存储环境值的字典，键为字符串，值为对象类型
/// </summary>
protected readonly Dictionary<string, object> Values = new();
/// <summary>
/// 获取环境名称的抽象属性
/// 获取环境名称的抽象属性
/// </summary>
public abstract string Name { get; }
/// <summary>
/// 根据键获取指定类型的值
/// 根据键获取指定类型的值
/// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找值的键</param>
@ -30,7 +30,7 @@ public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
}
/// <summary>
/// 尝试根据键获取指定类型的值
/// 尝试根据键获取指定类型的值
/// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找值的键</param>
@ -49,7 +49,7 @@ public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
}
/// <summary>
/// 根据键获取必需的指定类型值，如果找不到则抛出异常
/// 根据键获取必需的指定类型值，如果找不到则抛出异常
/// </summary>
/// <typeparam name="T">要获取的值的类型，必须为引用类型</typeparam>
/// <param name="key">用于查找值的键</param>
@ -72,7 +72,7 @@ public abstract class EnvironmentBase : ContextAwareBase, IEnvironment
public abstract void Initialize();
/// <summary>
/// 注册键值对到环境值字典中
/// 注册键值对到环境值字典中
/// </summary>
/// <param name="key">要注册的键</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;
/// <summary>
/// 提供对 IContextAware 接口的扩展方法
/// 提供对 IContextAware 接口的扩展方法
/// </summary>
public static class ContextAwareExtensions
{
/// <summary>
/// 获取架构上下文中的指定系统
/// 获取架构上下文中的指定系统
/// </summary>
/// <typeparam name="TSystem">目标系统类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -29,7 +29,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 获取架构上下文中的指定模型
/// 获取架构上下文中的指定模型
/// </summary>
/// <typeparam name="TModel">目标模型类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -43,7 +43,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 获取架构上下文中的指定工具
/// 获取架构上下文中的指定工具
/// </summary>
/// <typeparam name="TUtility">目标工具类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -57,7 +57,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 发送一个查询请求
/// 发送一个查询请求
/// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -74,7 +74,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 发送一个无返回结果的命令
/// 发送一个无返回结果的命令
/// </summary>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
@ -89,7 +89,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 发送一个带返回值的命令
/// 发送一个带返回值的命令
/// </summary>
/// <typeparam name="TResult">命令执行结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -106,7 +106,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 发送一个事件
/// 发送一个事件
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -119,7 +119,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 发送一个具体的事件实例
/// 发送一个具体的事件实例
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -135,7 +135,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 注册事件处理器
/// 注册事件处理器
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -151,7 +151,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 取消对某类型事件的监听
/// 取消对某类型事件的监听
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
@ -168,7 +168,7 @@ public static class ContextAwareExtensions
/// <summary>
/// 获取指定类型的环境对象
/// 获取指定类型的环境对象
/// </summary>
/// <typeparam name="T">要获取的环境对象类型</typeparam>
/// <param name="contextAware">上下文感知对象</param>
@ -182,7 +182,7 @@ public static class ContextAwareExtensions
}
/// <summary>
/// 获取环境对象
/// 获取环境对象
/// </summary>
/// <param name="contextAware">上下文感知对象</param>
/// <returns>环境对象</returns>

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

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

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

@ -3,20 +3,22 @@
namespace GFramework.Core.logging;
/// <summary>
/// 控制台日志记录器工厂提供程序，用于创建控制台日志记录器实例
/// 控制台日志记录器工厂提供程序，用于创建控制台日志记录器实例
/// </summary>
public sealed class ConsoleLoggerFactoryProvider : ILoggerFactoryProvider
{
/// <summary>
/// 获取或设置日志记录器的最小日志级别，低于此级别的日志将被忽略
/// 获取或设置日志记录器的最小日志级别，低于此级别的日志将被忽略
/// </summary>
public LogLevel MinLevel { get; set; } = LogLevel.Info;
/// <summary>
/// 创建一个日志记录器实例
/// 创建一个日志记录器实例
/// </summary>
/// <param name="name">日志记录器的名称，用于标识特定的日志源</param>
/// <returns>配置了指定名称和最小日志级别的ILogger实例</returns>
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;
/// <summary>
/// 日志工厂提供程序解析器，用于管理和提供日志工厂提供程序实例
/// 日志工厂提供程序解析器，用于管理和提供日志工厂提供程序实例
/// </summary>
public static class LoggerFactoryResolver
{
/// <summary>
/// 获取或设置当前的日志工厂提供程序
/// 获取或设置当前的日志工厂提供程序
/// </summary>
/// <value>
/// 日志工厂提供程序实例，默认为控制台日志工厂提供程序
/// 日志工厂提供程序实例，默认为控制台日志工厂提供程序
/// </value>
public static ILoggerFactoryProvider Provider { get; set; }
= new ConsoleLoggerFactoryProvider();
/// <summary>
/// 获取或设置日志记录的最小级别
/// 获取或设置日志记录的最小级别
/// </summary>
/// <value>
/// 日志级别枚举值，默认为Info级别
/// 日志级别枚举值，默认为Info级别
/// </value>
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时才执行注销操作
if (BindableProperty != null && OnValueChanged != null)
{
// 调用可绑定属性的注销方法，传入值变化回调函数
BindableProperty.UnRegister(OnValueChanged);
}
// 清理属性引用
BindableProperty = null;

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

@ -3,12 +3,12 @@
namespace GFramework.Core.query;
/// <summary>
/// 查询总线实现，负责执行查询并返回结果
/// 查询总线实现，负责执行查询并返回结果
/// </summary>
public sealed class QueryBus : IQueryBus
{
/// <summary>
/// 执行指定的查询并返回结果
/// 执行指定的查询并返回结果
/// </summary>
/// <typeparam name="TResult">查询结果的类型</typeparam>
/// <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>
public static class AssetCatalog
public interface IAssetId
{
/// <summary>
/// 资源标识符接口，定义了资源路径的访问接口
/// 获取资源的路径
/// </summary>
public interface IAssetId
{
/// <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;
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;
}

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

@ -3,10 +3,9 @@
// when targeting netstandard2.0 or older frameworks.
#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

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

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

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

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

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

@ -1,7 +1,4 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using GFramework.Core.Abstractions.architecture;
using GFramework.Core.Abstractions.architecture;
using GFramework.Core.Abstractions.environment;
using GFramework.Core.architecture;
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;

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

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

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

@ -1,6 +1,4 @@
using System;
using System.Collections.Generic;
using GFramework.Core.Abstractions.system;
using GFramework.Core.Abstractions.system;
using GFramework.Game.Abstractions.assets;
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 Godot;

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

@ -3,7 +3,7 @@
namespace GFramework.Godot.extensions.signal;
/// <summary>
/// 信号连接构建器，用于以流畅的方式连接Godot信号
/// 信号连接构建器，用于以流畅的方式连接Godot信号
/// </summary>
/// <param name="target">要连接信号的目标节点</param>
/// <param name="signal">要连接的信号名称</param>
@ -12,7 +12,7 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
private GodotObject.ConnectFlags? _flags;
/// <summary>
/// 设置连接标志
/// 设置连接标志
/// </summary>
/// <param name="flags">连接标志</param>
/// <returns>当前构建器实例</returns>
@ -23,7 +23,7 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
}
/// <summary>
/// 连接信号到指定的可调用对象
/// 连接信号到指定的可调用对象
/// </summary>
/// <param name="callable">要连接的可调用对象</param>
/// <param name="flags">连接标志</param>
@ -41,7 +41,7 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
}
/// <summary>
/// 连接信号到指定的可调用对象并立即调用
/// 连接信号到指定的可调用对象并立即调用
/// </summary>
/// <param name="callable">要连接的可调用对象</param>
/// <param name="flags">连接标志</param>
@ -55,8 +55,11 @@ public sealed class SignalBuilder(GodotObject target, StringName signal)
}
/// <summary>
/// 显式结束，返回 Node
/// 显式结束，返回 Node
/// </summary>
/// <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;
/// <summary>
/// 为Godot Node节点提供信号相关的流畅API扩展方法
/// 为Godot Node节点提供信号相关的流畅API扩展方法
/// </summary>
public static class SignalFluentExtensions
{
/// <summary>
/// 为指定节点创建信号构建器
/// 为指定节点创建信号构建器
/// </summary>
/// <param name="object">要创建信号构建器的Godot对象</param>
/// <param name="signal">信号名称</param>
@ -16,5 +16,7 @@ public static class SignalFluentExtensions
public static SignalBuilder Signal(
this GodotObject @object,
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()}]";
// 添加异常信息
if (exception != null)
{
message += "\n" + exception;
}
if (exception != null) message += "\n" + exception;
var logMessage = $"{logPrefix} {message}";

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

@ -3,19 +3,22 @@
namespace GFramework.Godot.logging;
/// <summary>
/// Godot日志工厂提供程序，用于创建Godot日志记录器实例
/// Godot日志工厂提供程序，用于创建Godot日志记录器实例
/// </summary>
public sealed class GodotLoggerFactoryProvider : ILoggerFactoryProvider
{
/// <summary>
/// 获取或设置最小日志级别
/// 获取或设置最小日志级别
/// </summary>
public LogLevel MinLevel { get; set; }
/// <summary>
/// 创建指定名称的日志记录器实例
/// 创建指定名称的日志记录器实例
/// </summary>
/// <param name="name">日志记录器的名称</param>
/// <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.system;
using GFramework.Game.Abstractions.assets;

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

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

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

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

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

@ -5,17 +5,17 @@ using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace GFramework.SourceGenerators.Common.generator;
/// <summary>
/// 属性枚举生成器基类，用于基于特定属性的枚举进行源代码生成
/// 属性枚举生成器基类，用于基于特定属性的枚举进行源代码生成
/// </summary>
public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
{
/// <summary>
/// 获取属性的短名称（不包含后缀）
/// 获取属性的短名称（不包含后缀）
/// </summary>
protected abstract string AttributeShortNameWithoutSuffix { get; }
/// <summary>
/// 初始化增量生成器
/// 初始化增量生成器
/// </summary>
/// <param name="context">增量生成器初始化上下文</param>
public void Initialize(IncrementalGeneratorInitializationContext context)
@ -31,7 +31,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
(ctx, _) =>
{
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);
})
.Where(x => x.symbol is not null);
@ -57,7 +57,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
}
/// <summary>
/// 解析指定符号上的属性数据
/// 解析指定符号上的属性数据
/// </summary>
/// <param name="compilation">编译对象</param>
/// <param name="symbol">命名类型符号</param>
@ -67,7 +67,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
INamedTypeSymbol symbol);
/// <summary>
/// 验证符号是否符合生成要求
/// 验证符号是否符合生成要求
/// </summary>
/// <param name="context">源生产上下文</param>
/// <param name="compilation">编译对象</param>
@ -83,7 +83,7 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
AttributeData attr);
/// <summary>
/// 生成源代码
/// 生成源代码
/// </summary>
/// <param name="symbol">命名类型符号</param>
/// <param name="attr">属性数据</param>
@ -93,10 +93,12 @@ public abstract class AttributeEnumGeneratorBase : IIncrementalGenerator
AttributeData attr);
/// <summary>
/// 获取生成文件的提示名称
/// 获取生成文件的提示名称
/// </summary>
/// <param name="symbol">命名类型符号</param>
/// <returns>生成文件的提示名称</returns>
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;
/// <summary>
/// 元数据属性类生成器基类，用于基于元数据名称解析特性的抽象基类
/// 元数据属性类生成器基类，用于基于元数据名称解析特性的抽象基类
/// </summary>
public abstract class MetadataAttributeClassGeneratorBase
: AttributeClassGeneratorBase
{
/// <summary>
/// 获取特性元数据名称的抽象属性
/// 获取特性元数据名称的抽象属性
/// </summary>
protected abstract string AttributeMetadataName { get; }
/// <summary>
/// 根据元数据名称解析指定符号上的特性
/// 根据元数据名称解析指定符号上的特性
/// </summary>
/// <param name="compilation">编译对象，用于获取类型信息</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;
/// <summary>
/// 基于类型特性的类生成器基类
/// 基于类型特性的类生成器基类
/// </summary>
public abstract class TypeAttributeClassGeneratorBase
: AttributeClassGeneratorBase
{
/// <summary>
/// 获取要处理的特性类型
/// 获取要处理的特性类型
/// </summary>
protected abstract Type AttributeType { get; }
/// <summary>
/// 解析指定符号上的特性
/// 解析指定符号上的特性
/// </summary>
/// <param name="compilation">编译对象（未使用）</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;
/// <summary>
/// 用于测试源代码生成器的快照测试类
/// 用于测试源代码生成器的快照测试类
/// </summary>
/// <typeparam name="TGenerator">要测试的源代码生成器类型</typeparam>
public static class GeneratorSnapshotTest<TGenerator>
where TGenerator : new()
{
/// <summary>
/// 运行源代码生成器的快照测试
/// 运行源代码生成器的快照测试
/// </summary>
/// <param name="source">输入的源代码字符串</param>
/// <param name="snapshotFolder">快照文件存储的文件夹路径</param>
@ -61,10 +61,12 @@ public static class GeneratorSnapshotTest<TGenerator>
}
/// <summary>
/// 标准化文本内容，将换行符统一为\n并去除首尾空白
/// 标准化文本内容，将换行符统一为\n并去除首尾空白
/// </summary>
/// <param name="text">要标准化的文本</param>
/// <returns>标准化后的文本</returns>
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;
/// <summary>
/// 上下文感知生成器快照测试类
/// 用于测试ContextAwareGenerator源代码生成器的输出快照
/// 上下文感知生成器快照测试类
/// 用于测试ContextAwareGenerator源代码生成器的输出快照
/// </summary>
[TestFixture]
public class ContextAwareGeneratorSnapshotTests
{
/// <summary>
/// 测试ContextAwareGenerator源代码生成器的快照功能
/// 验证生成器对带有ContextAware特性的类的处理结果
/// 测试ContextAwareGenerator源代码生成器的快照功能
/// 验证生成器对带有ContextAware特性的类的处理结果
/// </summary>
/// <returns>异步任务，无返回值</returns>
[Test]
@ -75,7 +75,7 @@ public class ContextAwareGeneratorSnapshotTests
// 执行生成器快照测试，将生成的代码与预期快照进行比较
await GeneratorSnapshotTest<ContextAwareGenerator>.RunAsync(
source,
snapshotFolder: Path.Combine(
Path.Combine(
TestContext.CurrentContext.TestDirectory,
"rule",
"snapshots",

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

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

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

@ -9,7 +9,7 @@ using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace GFramework.SourceGenerators.enums;
/// <summary>
/// 枚举扩展方法生成器，用于自动生成枚举相关的扩展方法
/// 枚举扩展方法生成器，用于自动生成枚举相关的扩展方法
/// </summary>
[Generator]
public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
@ -18,7 +18,7 @@ public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
$"{PathContests.SourceGeneratorsAbstractionsPath}.enums.GenerateEnumExtensionsAttribute";
/// <summary>
/// 仅用于 Syntax 粗筛选
/// 仅用于 Syntax 粗筛选
/// </summary>
protected override string AttributeShortNameWithoutSuffix => "GenerateEnumExtensions";
@ -49,7 +49,7 @@ public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
}
/// <summary>
/// 生成枚举扩展方法的源代码
/// 生成枚举扩展方法的源代码
/// </summary>
/// <param name="symbol">枚举类型符号</param>
/// <param name="attr">属性数据</param>
@ -103,10 +103,12 @@ public sealed class EnumExtensionsGenerator : AttributeEnumGeneratorBase
}
/// <summary>
/// 获取生成文件的提示名称
/// 获取生成文件的提示名称
/// </summary>
/// <param name="symbol">命名类型符号</param>
/// <returns>生成文件的提示名称</returns>
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
{
/// <summary>
/// 获取属性元数据的完整名称，用于标识日志属性的完全限定名
/// 获取属性元数据的完整名称，用于标识日志属性的完全限定名
/// </summary>
protected override Type AttributeType => typeof(LogAttribute);
/// <summary>
/// 用于语法快速筛选
/// 用于语法快速筛选
/// </summary>
protected override string AttributeShortNameWithoutSuffix => "Log";
/// <summary>
/// 对类进行额外语义校验（可选）
/// 对类进行额外语义校验（可选）
/// </summary>
protected override bool ValidateSymbol(
SourceProductionContext context,
@ -99,11 +99,15 @@ public sealed class LoggerGenerator : TypeAttributeClassGeneratorBase
}
/// <summary>
/// 可以自定义生成文件名
/// 可以自定义生成文件名
/// </summary>
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)
=> 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;
/// <summary>
/// 上下文感知生成器，用于为标记了ContextAware特性的类自动生成IContextAware接口实现
/// 上下文感知生成器，用于为标记了ContextAware特性的类自动生成IContextAware接口实现
/// </summary>
[Generator]
public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
{
/// <summary>
/// 获取特性的元数据名称
/// 获取特性的元数据名称
/// </summary>
protected override string AttributeMetadataName =>
$"{PathContests.SourceGeneratorsAbstractionsPath}.rule.ContextAwareAttribute";
/// <summary>
/// 获取特性的短名称（不包含后缀）
/// 获取特性的短名称（不包含后缀）
/// </summary>
protected override string AttributeShortNameWithoutSuffix => "ContextAware";
/// <summary>
/// 验证符号是否符合生成条件
/// 验证符号是否符合生成条件
/// </summary>
/// <param name="context">源生产上下文</param>
/// <param name="compilation">编译对象</param>
@ -68,7 +68,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
/// <summary>
/// 生成源代码
/// 生成源代码
/// </summary>
/// <param name="context">源生产上下文</param>
/// <param name="compilation">编译对象</param>
@ -112,18 +112,20 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
}
/// <summary>
/// 获取生成文件的提示名称
/// 获取生成文件的提示名称
/// </summary>
/// <param name="symbol">命名类型符号</param>
/// <returns>生成文件的提示名称</returns>
protected override string GetHintName(INamedTypeSymbol symbol)
=> $"{symbol.Name}.ContextAware.g.cs";
{
return $"{symbol.Name}.ContextAware.g.cs";
}
// =========================
// Context 属性（无 global::，与测试一致）
// =========================
/// <summary>
/// 生成Context属性
/// 生成Context属性
/// </summary>
/// <param name="sb">字符串构建器</param>
private static void GenerateContextProperty(StringBuilder sb)
@ -154,7 +156,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
// 显式接口实现（使用 global::）
// =========================
/// <summary>
/// 生成接口实现
/// 生成接口实现
/// </summary>
/// <param name="sb">字符串构建器</param>
/// <param name="interfaceSymbol">接口符号</param>
@ -176,7 +178,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
}
/// <summary>
/// 生成方法实现
/// 生成方法实现
/// </summary>
/// <param name="sb">字符串构建器</param>
/// <param name="interfaceName">接口名称</param>
@ -203,7 +205,7 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
}
/// <summary>
/// 生成方法体
/// 生成方法体
/// </summary>
/// <param name="sb">字符串构建器</param>
/// <param name="method">方法符号</param>
@ -223,10 +225,8 @@ public sealed class ContextAwareGenerator : MetadataAttributeClassGeneratorBase
default:
if (!method.ReturnsVoid)
{
sb.AppendLine(
$" throw new System.NotImplementedException(\"Method '{method.Name}' is not supported.\");");
}
break;
}