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

feat(architecture): 添加批量获取组件实例的功能

Browse Source 
- 在 ArchitectureContext 中添加 GetServices、GetSystems、GetModels 和 GetUtilities 方法
- 扩展 IArchitectureContext 接口以支持批量获取各类组件实例
- 在测试类中实现相应的批量获取功能
- 将原有的 ContextAwareExtensions 拆分为多个专门的扩展类文件
- 新增 ContextAwareCommandExtensions、ContextAwareEnvironmentExtensions 和 ContextAwareEventExtensions 等扩展类
- 提供了更完善的架构上下文组件访问能力
This commit is contained in:
GeWuYou 2026-03-04 22:46:50 +08:00 committed by gewuyou
parent d88aa12014
commit bde1af2c2e
14 changed files with 1209 additions and 459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
GFramework.Core.Abstractions/architecture/IArchitectureContext.cs
View File

@ -22,6 +22,13 @@ public interface IArchitectureContext
/// <returns>服务实例，如果不存在则返回null</returns>
TService? GetService<TService>() where TService : class;
/// <summary>
/// 获取指定类型的所有服务实例
/// </summary>
/// <typeparam name="TService">服务类型</typeparam>
/// <returns>所有符合条件的服务实例列表</returns>
IReadOnlyList<TService> GetServices<TService>() where TService : class;
/// <summary>
/// 获取指定类型的系统实例
/// </summary>
@ -29,6 +36,13 @@ public interface IArchitectureContext
/// <returns>系统实例，如果不存在则返回null</returns>
TSystem? GetSystem<TSystem>() where TSystem : class, ISystem;
/// <summary>
/// 获取指定类型的所有系统实例
/// </summary>
/// <typeparam name="TSystem">系统类型，必须继承自ISystem接口</typeparam>
/// <returns>所有符合条件的系统实例列表</returns>
IReadOnlyList<TSystem> GetSystems<TSystem>() where TSystem : class, ISystem;
/// <summary>
/// 获取指定类型的模型实例
/// </summary>
@ -36,6 +50,13 @@ public interface IArchitectureContext
/// <returns>模型实例，如果不存在则返回null</returns>
TModel? GetModel<TModel>() where TModel : class, IModel;
/// <summary>
/// 获取指定类型的所有模型实例
/// </summary>
/// <typeparam name="TModel">模型类型，必须继承自IModel接口</typeparam>
/// <returns>所有符合条件的模型实例列表</returns>
IReadOnlyList<TModel> GetModels<TModel>() where TModel : class, IModel;
/// <summary>
/// 获取指定类型的工具类实例
/// </summary>
@ -43,6 +64,13 @@ public interface IArchitectureContext
/// <returns>工具类实例，如果不存在则返回null</returns>
TUtility? GetUtility<TUtility>() where TUtility : class, IUtility;
/// <summary>
/// 获取指定类型的所有工具类实例
/// </summary>
/// <typeparam name="TUtility">工具类类型，必须继承自IUtility接口</typeparam>
/// <returns>所有符合条件的工具类实例列表</returns>
IReadOnlyList<TUtility> GetUtilities<TUtility>() where TUtility : class, IUtility;
/// <summary>
/// 发送一个命令
/// </summary>

20
GFramework.Core.Tests/architecture/ArchitectureServicesTests.cs
View File

@ -305,21 +305,41 @@ public class TestArchitectureContextV3 : IArchitectureContext
return _container.Get<TService>();
}
public IReadOnlyList<TService> GetServices<TService>() where TService : class
{
return _container.GetAll<TService>();
}
public TModel? GetModel<TModel>() where TModel : class, IModel
{
return _container.Get<TModel>();
}
public IReadOnlyList<TModel> GetModels<TModel>() where TModel : class, IModel
{
return _container.GetAll<TModel>();
}
public TSystem? GetSystem<TSystem>() where TSystem : class, ISystem
{
return _container.Get<TSystem>();
}
public IReadOnlyList<TSystem> GetSystems<TSystem>() where TSystem : class, ISystem
{
return _container.GetAll<TSystem>();
}
public TUtility? GetUtility<TUtility>() where TUtility : class, IUtility
{
return _container.Get<TUtility>();
}
public IReadOnlyList<TUtility> GetUtilities<TUtility>() where TUtility : class, IUtility
{
return _container.GetAll<TUtility>();
}
public void SendEvent<TEvent>() where TEvent : new()
{
}

40
GFramework.Core.Tests/architecture/GameContextTests.cs
View File

@ -268,6 +268,16 @@ public class TestArchitectureContext : IArchitectureContext
return _container.Get<TService>();
}
/// <summary>
/// 获取指定类型的所有服务
/// </summary>
/// <typeparam name="TService">服务类型</typeparam>
/// <returns>所有服务实例列表</returns>
public IReadOnlyList<TService> GetServices<TService>() where TService : class
{
return _container.GetAll<TService>();
}
/// <summary>
/// 获取指定类型的模型
/// </summary>
@ -278,6 +288,16 @@ public class TestArchitectureContext : IArchitectureContext
return _container.Get<TModel>();
}
/// <summary>
/// 获取指定类型的所有模型
/// </summary>
/// <typeparam name="TModel">模型类型</typeparam>
/// <returns>所有模型实例列表</returns>
public IReadOnlyList<TModel> GetModels<TModel>() where TModel : class, IModel
{
return _container.GetAll<TModel>();
}
/// <summary>
/// 获取指定类型的系统
/// </summary>
@ -288,6 +308,16 @@ public class TestArchitectureContext : IArchitectureContext
return _container.Get<TSystem>();
}
/// <summary>
/// 获取指定类型的所有系统
/// </summary>
/// <typeparam name="TSystem">系统类型</typeparam>
/// <returns>所有系统实例列表</returns>
public IReadOnlyList<TSystem> GetSystems<TSystem>() where TSystem : class, ISystem
{
return _container.GetAll<TSystem>();
}
/// <summary>
/// 获取指定类型的工具
/// </summary>
@ -298,6 +328,16 @@ public class TestArchitectureContext : IArchitectureContext
return _container.Get<TUtility>();
}
/// <summary>
/// 获取指定类型的所有工具
/// </summary>
/// <typeparam name="TUtility">工具类型</typeparam>
/// <returns>所有工具实例列表</returns>
public IReadOnlyList<TUtility> GetUtilities<TUtility>() where TUtility : class, IUtility
{
return _container.GetAll<TUtility>();
}
/// <summary>
/// 发送事件
/// </summary>

133
GFramework.Core.Tests/rule/ContextAwareEnvironmentExtensionsTests.cs Normal file
View File

@ -0,0 +1,133 @@
using GFramework.Core.Abstractions.environment;
using GFramework.Core.Abstractions.rule;
using GFramework.Core.architecture;
using GFramework.Core.extensions;
using GFramework.Core.ioc;
using GFramework.Core.rule;
using NUnit.Framework;
namespace GFramework.Core.Tests.rule;
/// <summary>
/// 测试 ContextAwareEnvironmentExtensions 的单元测试类
/// 验证环境对象的获取功能
/// </summary>
[TestFixture]
public class ContextAwareEnvironmentExtensionsTests
{
[SetUp]
public void SetUp()
{
_container = new MicrosoftDiContainer();
_context = new ArchitectureContext(_container);
_contextAware = new TestContextAware();
((IContextAware)_contextAware).SetContext(_context);
}
[TearDown]
public void TearDown()
{
_container.Clear();
}
private TestContextAware _contextAware = null!;
private ArchitectureContext _context = null!;
private MicrosoftDiContainer _container = null!;
[Test]
public void GetEnvironment_Should_Return_Registered_Environment()
{
// Arrange
var environment = new TestEnvironment();
_container.Register<IEnvironment>(environment);
_container.Freeze();
// Act
var result = _contextAware.GetEnvironment();
// Assert
Assert.That(result, Is.SameAs(environment));
}
[Test]
public void GetEnvironment_Generic_Should_Return_Typed_Environment()
{
// Arrange
var environment = new TestEnvironment { Name = "TestEnv" };
_container.Register<IEnvironment>(environment);
_container.Freeze();
// Act
var result = _contextAware.GetEnvironment<TestEnvironment>();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.SameAs(environment));
Assert.That(result!.Name, Is.EqualTo("TestEnv"));
}
[Test]
public void GetEnvironment_Generic_Should_Return_Null_When_Type_Mismatch()
{
// Arrange
var environment = new TestEnvironment();
_container.Register<IEnvironment>(environment);
_container.Freeze();
// Act
var result = _contextAware.GetEnvironment<AnotherEnvironment>();
// Assert
Assert.That(result, Is.Null);
}
private class TestEnvironment : IEnvironment
{
public string Name { get; set; } = string.Empty;
public T? Get<T>(string key) where T : class => default;
public bool TryGet<T>(string key, out T value) where T : class
{
value = default!;
return false;
}
public T GetRequired<T>(string key) where T : class => throw new NotImplementedException();
public void Register(string key, object value)
{
}
public void Initialize()
{
}
}
private class AnotherEnvironment : IEnvironment
{
public string Name => "Another";
public T? Get<T>(string key) where T : class => default;
public bool TryGet<T>(string key, out T value) where T : class
{
value = default!;
return false;
}
public T GetRequired<T>(string key) where T : class => throw new NotImplementedException();
public void Register(string key, object value)
{
}
public void Initialize()
{
}
}
private class TestContextAware : ContextAwareBase
{
}
}

128
GFramework.Core.Tests/rule/ContextAwareEventExtensionsTests.cs Normal file
View File

@ -0,0 +1,128 @@
using GFramework.Core.Abstractions.events;
using GFramework.Core.Abstractions.rule;
using GFramework.Core.architecture;
using GFramework.Core.events;
using GFramework.Core.extensions;
using GFramework.Core.ioc;
using GFramework.Core.rule;
using NUnit.Framework;
namespace GFramework.Core.Tests.rule;
/// <summary>
/// 测试 ContextAwareEventExtensions 的单元测试类
/// 验证事件发送、注册和取消注册功能
/// </summary>
[TestFixture]
public class ContextAwareEventExtensionsTests
{
[SetUp]
public void SetUp()
{
_container = new MicrosoftDiContainer();
_eventBus = new EventBus();
_container.Register<IEventBus>(_eventBus);
_context = new ArchitectureContext(_container);
_contextAware = new TestContextAware();
((IContextAware)_contextAware).SetContext(_context);
_container.Freeze();
}
[TearDown]
public void TearDown()
{
_container.Clear();
}
private TestContextAware _contextAware = null!;
private ArchitectureContext _context = null!;
private MicrosoftDiContainer _container = null!;
private EventBus _eventBus = null!;
[Test]
public void SendEvent_Should_Trigger_Registered_Handler()
{
// Arrange
var eventReceived = false;
_contextAware.RegisterEvent<TestEvent>(_ => eventReceived = true);
// Act
_contextAware.SendEvent(new TestEvent());
// Assert
Assert.That(eventReceived, Is.True);
}
[Test]
public void SendEvent_WithNew_Should_Create_And_Send_Event()
{
// Arrange
var eventReceived = false;
_contextAware.RegisterEvent<TestEventWithDefaultConstructor>(_ => eventReceived = true);
// Act
_contextAware.SendEvent<TestEventWithDefaultConstructor>();
// Assert
Assert.That(eventReceived, Is.True);
}
[Test]
public void RegisterEvent_Should_Return_UnRegister_Interface()
{
// Act
var unRegister = _contextAware.RegisterEvent<TestEvent>(_ => { });
// Assert
Assert.That(unRegister, Is.Not.Null);
Assert.That(unRegister, Is.InstanceOf<IUnRegister>());
}
[Test]
public void UnRegisterEvent_Should_Stop_Receiving_Events()
{
// Arrange
var eventCount = 0;
void Handler(TestEvent e) => eventCount++;
_contextAware.RegisterEvent<TestEvent>(Handler);
_contextAware.SendEvent(new TestEvent());
// Act
_contextAware.UnRegisterEvent<TestEvent>(Handler);
_contextAware.SendEvent(new TestEvent());
// Assert
Assert.That(eventCount, Is.EqualTo(1));
}
[Test]
public void SendEvent_Should_Pass_Event_Data()
{
// Arrange
TestEvent? receivedEvent = null;
_contextAware.RegisterEvent<TestEvent>(e => receivedEvent = e);
var sentEvent = new TestEvent { Data = "TestData" };
// Act
_contextAware.SendEvent(sentEvent);
// Assert
Assert.That(receivedEvent, Is.Not.Null);
Assert.That(receivedEvent!.Data, Is.EqualTo("TestData"));
}
private class TestEvent
{
public string Data { get; set; } = string.Empty;
}
private class TestEventWithDefaultConstructor
{
}
private class TestContextAware : ContextAwareBase
{
}
}

259
GFramework.Core.Tests/rule/ContextAwareServiceExtensionsTests.cs Normal file
View File

@ -0,0 +1,259 @@
using GFramework.Core.Abstractions.architecture;
using GFramework.Core.Abstractions.enums;
using GFramework.Core.Abstractions.model;
using GFramework.Core.Abstractions.rule;
using GFramework.Core.Abstractions.system;
using GFramework.Core.Abstractions.utility;
using GFramework.Core.architecture;
using GFramework.Core.extensions;
using GFramework.Core.ioc;
using GFramework.Core.rule;
using NUnit.Framework;
namespace GFramework.Core.Tests.rule;
/// <summary>
/// 测试 ContextAwareServiceExtensions 的单元测试类
/// 验证服务、系统、模型、工具的单例和批量获取功能
/// </summary>
[TestFixture]
public class ContextAwareServiceExtensionsTests
{
[SetUp]
public void SetUp()
{
_container = new MicrosoftDiContainer();
_context = new ArchitectureContext(_container);
_contextAware = new TestContextAware();
((IContextAware)_contextAware).SetContext(_context);
}
[TearDown]
public void TearDown()
{
_container.Clear();
}
private TestContextAware _contextAware = null!;
private ArchitectureContext _context = null!;
private MicrosoftDiContainer _container = null!;
[Test]
public void GetService_Should_Return_Registered_Service()
{
// Arrange
var service = new TestService();
_container.Register(service);
_container.Freeze();
// Act
var result = _contextAware.GetService<TestService>();
// Assert
Assert.That(result, Is.SameAs(service));
}
[Test]
public void GetSystem_Should_Return_Registered_System()
{
// Arrange
var system = new TestSystem();
_container.RegisterSystem(system);
_container.Freeze();
// Act
var result = _contextAware.GetSystem<TestSystem>();
// Assert
Assert.That(result, Is.SameAs(system));
}
[Test]
public void GetModel_Should_Return_Registered_Model()
{
// Arrange
var model = new TestModel();
_container.Register(model);
_container.Freeze();
// Act
var result = _contextAware.GetModel<TestModel>();
// Assert
Assert.That(result, Is.SameAs(model));
}
[Test]
public void GetUtility_Should_Return_Registered_Utility()
{
// Arrange
var utility = new TestUtility();
_container.Register(utility);
_container.Freeze();
// Act
var result = _contextAware.GetUtility<TestUtility>();
// Assert
Assert.That(result, Is.SameAs(utility));
}
[Test]
public void GetServices_Should_Return_All_Registered_Services()
{
// Arrange
var service1 = new TestService { Name = "Service1" };
var service2 = new TestService { Name = "Service2" };
_container.Register<TestService>(service1);
_container.Register<TestService>(service2);
_container.Freeze();
// Act
var results = _contextAware.GetServices<TestService>();
// Assert
Assert.That(results, Has.Count.EqualTo(2));
Assert.That(results, Contains.Item(service1));
Assert.That(results, Contains.Item(service2));
}
[Test]
public void GetSystems_Should_Return_All_Registered_Systems()
{
// Arrange
var system1 = new TestSystem { Name = "System1" };
var system2 = new TestSystem { Name = "System2" };
_container.RegisterSystem(system1);
_container.RegisterSystem(system2);
_container.Freeze();
// Act
var results = _contextAware.GetSystems<ISystem>();
// Assert
Assert.That(results, Has.Count.GreaterThanOrEqualTo(2));
Assert.That(results.Any(s => s is TestSystem ts && ts.Name == "System1"), Is.True);
Assert.That(results.Any(s => s is TestSystem ts && ts.Name == "System2"), Is.True);
}
[Test]
public void GetModels_Should_Return_All_Registered_Models()
{
// Arrange
var model1 = new TestModel { Name = "Model1" };
var model2 = new TestModel { Name = "Model2" };
_container.Register(model1);
_container.Register(model2);
_container.Freeze();
// Act
var results = _contextAware.GetModels<TestModel>();
// Assert
Assert.That(results, Has.Count.EqualTo(2));
Assert.That(results.Any(m => m.Name == "Model1"), Is.True);
Assert.That(results.Any(m => m.Name == "Model2"), Is.True);
}
[Test]
public void GetUtilities_Should_Return_All_Registered_Utilities()
{
// Arrange
var utility1 = new TestUtility { Name = "Utility1" };
var utility2 = new TestUtility { Name = "Utility2" };
_container.Register(utility1);
_container.Register(utility2);
_container.Freeze();
// Act
var results = _contextAware.GetUtilities<TestUtility>();
// Assert
Assert.That(results, Has.Count.EqualTo(2));
Assert.That(results.Any(u => u.Name == "Utility1"), Is.True);
Assert.That(results.Any(u => u.Name == "Utility2"), Is.True);
}
[Test]
public void GetServices_Should_Return_Empty_List_When_No_Services_Registered()
{
// Arrange
_container.Freeze();
// Act
var results = _contextAware.GetServices<TestService>();
// Assert
Assert.That(results, Is.Empty);
}
[Test]
public void GetSystems_Should_Return_Empty_List_When_No_Systems_Registered()
{
// Arrange
_container.Freeze();
// Act
var results = _contextAware.GetSystems<TestSystem>();
// Assert
Assert.That(results, Is.Empty);
}
private class TestService
{
public string Name { get; set; } = string.Empty;
}
private class TestSystem : ISystem
{
public string Name { get; set; } = string.Empty;
public void SetContext(IArchitectureContext context)
{
}
public IArchitectureContext GetContext() => null!;
public void OnArchitecturePhase(ArchitecturePhase phase)
{
}
public void Initialize()
{
}
public void Destroy()
{
}
}
private class TestModel : IModel
{
public string Name { get; set; } = string.Empty;
public void SetContext(IArchitectureContext context)
{
}
public IArchitectureContext GetContext() => null!;
public void OnArchitecturePhase(ArchitecturePhase phase)
{
}
public void Initialize()
{
}
}
private class TestUtility : IUtility
{
public string Name { get; set; } = string.Empty;
}
private class TestContextAware : ContextAwareBase
{
}
}

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

@ -233,6 +233,16 @@ public class ArchitectureContext(IIocContainer container) : IArchitectureContext
#region Component Retrieval
/// <summary>
/// 获取指定类型的所有服务实例
/// </summary>
/// <typeparam name="TService">服务类型</typeparam>
/// <returns>所有符合条件的服务实例列表</returns>
public IReadOnlyList<TService> GetServices<TService>() where TService : class
{
return _container.GetAll<TService>();
}
/// <summary>
/// 从IOC容器中获取指定类型的系统实例
/// </summary>
@ -243,6 +253,16 @@ public class ArchitectureContext(IIocContainer container) : IArchitectureContext
return GetService<TSystem>();
}
/// <summary>
/// 获取指定类型的所有系统实例
/// </summary>
/// <typeparam name="TSystem">系统类型</typeparam>
/// <returns>所有符合条件的系统实例列表</returns>
public IReadOnlyList<TSystem> GetSystems<TSystem>() where TSystem : class, ISystem
{
return _container.GetAll<TSystem>();
}
/// <summary>
/// 从IOC容器中获取指定类型的模型实例
/// </summary>
@ -253,6 +273,16 @@ public class ArchitectureContext(IIocContainer container) : IArchitectureContext
return GetService<TModel>();
}
/// <summary>
/// 获取指定类型的所有模型实例
/// </summary>
/// <typeparam name="TModel">模型类型</typeparam>
/// <returns>所有符合条件的模型实例列表</returns>
public IReadOnlyList<TModel> GetModels<TModel>() where TModel : class, IModel
{
return _container.GetAll<TModel>();
}
/// <summary>
/// 从IOC容器中获取指定类型的工具实例
/// </summary>
@ -263,6 +293,16 @@ public class ArchitectureContext(IIocContainer container) : IArchitectureContext
return GetService<TUtility>();
}
/// <summary>
/// 获取指定类型的所有工具实例
/// </summary>
/// <typeparam name="TUtility">工具类型</typeparam>
/// <returns>所有符合条件的工具实例列表</returns>
public IReadOnlyList<TUtility> GetUtilities<TUtility>() where TUtility : class, IUtility
{
return _container.GetAll<TUtility>();
}
#endregion
#region Command Execution

113
GFramework.Core/extensions/ContextAwareCommandExtensions.cs Normal file
View File

@ -0,0 +1,113 @@
using GFramework.Core.Abstractions.command;
using GFramework.Core.Abstractions.rule;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供对 IContextAware 接口的命令执行扩展方法
/// </summary>
public static class ContextAwareCommandExtensions
{
/// <summary>
/// [Mediator] 发送命令的同步版本（不推荐,仅用于兼容性）
/// </summary>
/// <typeparam name="TResponse">命令响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令对象</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static TResponse SendCommand<TResponse>(this IContextAware contextAware,
Mediator.ICommand<TResponse> command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendCommand(command);
}
/// <summary>
/// 发送一个带返回结果的命令
/// </summary>
/// <typeparam name="TResult">命令执行结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static TResult SendCommand<TResult>(this IContextAware contextAware,
Abstractions.command.ICommand<TResult> command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendCommand(command);
}
/// <summary>
/// 发送一个无返回结果的命令
/// </summary>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static void SendCommand(this IContextAware contextAware, Abstractions.command.ICommand command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
context.SendCommand(command);
}
/// <summary>
/// [Mediator] 异步发送命令并返回结果
/// </summary>
/// <typeparam name="TResponse">命令响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令对象</param>
/// <param name="cancellationToken">取消令牌,用于取消操作</param>
/// <returns>包含命令执行结果的ValueTask</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static ValueTask<TResponse> SendCommandAsync<TResponse>(this IContextAware contextAware,
Mediator.ICommand<TResponse> command, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendCommandAsync(command, cancellationToken);
}
/// <summary>
/// 发送并异步执行一个无返回值的命令
/// </summary>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static async Task SendCommandAsync(this IContextAware contextAware, IAsyncCommand command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
await context.SendCommandAsync(command);
}
/// <summary>
/// 发送并异步执行一个带返回值的命令
/// </summary>
/// <typeparam name="TResult">命令执行结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static async Task<TResult> SendCommandAsync<TResult>(this IContextAware contextAware,
IAsyncCommand<TResult> command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return await context.SendCommandAsync(command);
}
}

35
GFramework.Core/extensions/ContextAwareEnvironmentExtensions.cs Normal file
View File

@ -0,0 +1,35 @@
using GFramework.Core.Abstractions.environment;
using GFramework.Core.Abstractions.rule;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供对 IContextAware 接口的环境访问扩展方法
/// </summary>
public static class ContextAwareEnvironmentExtensions
{
/// <summary>
/// 获取指定类型的环境对象
/// </summary>
/// <typeparam name="T">要获取的环境对象类型</typeparam>
/// <param name="contextAware">上下文感知对象</param>
/// <returns>指定类型的环境对象,如果无法转换则返回null</returns>
public static T? GetEnvironment<T>(this IContextAware contextAware) where T : class
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetEnvironment() as T;
}
/// <summary>
/// 获取环境对象
/// </summary>
/// <param name="contextAware">上下文感知对象</param>
/// <returns>环境对象</returns>
public static IEnvironment GetEnvironment(this IContextAware contextAware)
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetEnvironment();
}
}

70
GFramework.Core/extensions/ContextAwareEventExtensions.cs Normal file
View File

@ -0,0 +1,70 @@
using GFramework.Core.Abstractions.events;
using GFramework.Core.Abstractions.rule;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供对 IContextAware 接口的事件管理扩展方法
/// </summary>
public static class ContextAwareEventExtensions
{
/// <summary>
/// 发送一个事件
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static void SendEvent<TEvent>(this IContextAware contextAware) where TEvent : new()
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
context.SendEvent<TEvent>();
}
/// <summary>
/// 发送一个具体的事件实例
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="e">事件实例</param>
/// <exception cref="ArgumentNullException">当 contextAware 或 e 为 null 时抛出</exception>
public static void SendEvent<TEvent>(this IContextAware contextAware, TEvent e) where TEvent : class
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(e);
var context = contextAware.GetContext();
context.SendEvent(e);
}
/// <summary>
/// 注册事件处理器
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="handler">事件处理委托</param>
/// <returns>事件注销接口</returns>
public static IUnRegister RegisterEvent<TEvent>(this IContextAware contextAware, Action<TEvent> handler)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(handler);
var context = contextAware.GetContext();
return context.RegisterEvent(handler);
}
/// <summary>
/// 取消对某类型事件的监听
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="onEvent">之前绑定的事件处理器</param>
public static void UnRegisterEvent<TEvent>(this IContextAware contextAware, Action<TEvent> onEvent)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(onEvent);
var context = contextAware.GetContext();
context.UnRegisterEvent(onEvent);
}
}

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

@ -1,459 +0,0 @@
using GFramework.Core.Abstractions.command;
using GFramework.Core.Abstractions.environment;
using GFramework.Core.Abstractions.events;
using GFramework.Core.Abstractions.model;
using GFramework.Core.Abstractions.query;
using GFramework.Core.Abstractions.rule;
using GFramework.Core.Abstractions.system;
using GFramework.Core.Abstractions.utility;
using Mediator;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供对 IContextAware 接口的扩展方法
/// </summary>
public static class ContextAwareExtensions
{
/// <summary>
/// 从上下文感知对象中获取指定类型的服务
/// </summary>
/// <typeparam name="TService">要获取的服务类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的上下文感知对象</param>
/// <returns>指定类型的服务实例,如果未找到则返回 null</returns>
/// <exception cref="ArgumentNullException">当 contextAware 参数为 null 时抛出</exception>
public static TService? GetService<TService>(this IContextAware contextAware) where TService : class
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetService<TService>();
}
/// <summary>
/// 获取架构上下文中的指定系统
/// </summary>
/// <typeparam name="TSystem">目标系统类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>指定类型的系统实例</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static TSystem? GetSystem<TSystem>(this IContextAware contextAware) where TSystem : class, ISystem
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetSystem<TSystem>();
}
/// <summary>
/// 获取架构上下文中的指定模型
/// </summary>
/// <typeparam name="TModel">目标模型类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>指定类型的模型实例</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static TModel? GetModel<TModel>(this IContextAware contextAware) where TModel : class, IModel
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetModel<TModel>();
}
/// <summary>
/// 获取架构上下文中的指定工具
/// </summary>
/// <typeparam name="TUtility">目标工具类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>指定类型的工具实例</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static TUtility? GetUtility<TUtility>(this IContextAware contextAware) where TUtility : class, IUtility
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetUtility<TUtility>();
}
/// <summary>
/// 发送一个事件
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static void SendEvent<TEvent>(this IContextAware contextAware) where TEvent : new()
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
context.SendEvent<TEvent>();
}
/// <summary>
/// 发送一个具体的事件实例
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="e">事件实例</param>
/// <exception cref="ArgumentNullException">当 contextAware 或 e 为 null 时抛出</exception>
public static void SendEvent<TEvent>(this IContextAware contextAware, TEvent e) where TEvent : class
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(e);
var context = contextAware.GetContext();
context.SendEvent(e);
}
/// <summary>
/// 注册事件处理器
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="handler">事件处理委托</param>
/// <returns>事件注销接口</returns>
public static IUnRegister RegisterEvent<TEvent>(this IContextAware contextAware, Action<TEvent> handler)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(handler);
var context = contextAware.GetContext();
return context.RegisterEvent(handler);
}
/// <summary>
/// 取消对某类型事件的监听
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="onEvent">之前绑定的事件处理器</param>
public static void UnRegisterEvent<TEvent>(this IContextAware contextAware, Action<TEvent> onEvent)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(onEvent);
// 获取上下文对象并取消事件注册
var context = contextAware.GetContext();
context.UnRegisterEvent(onEvent);
}
/// <summary>
/// 获取指定类型的环境对象
/// </summary>
/// <typeparam name="T">要获取的环境对象类型</typeparam>
/// <param name="contextAware">上下文感知对象</param>
/// <returns>指定类型的环境对象,如果无法转换则返回null</returns>
public static T? GetEnvironment<T>(this IContextAware contextAware) where T : class
{
ArgumentNullException.ThrowIfNull(contextAware);
// 获取上下文对象并返回其环境
var context = contextAware.GetContext();
return context.GetEnvironment() as T;
}
/// <summary>
/// 获取环境对象
/// </summary>
/// <param name="contextAware">上下文感知对象</param>
/// <returns>环境对象</returns>
public static IEnvironment GetEnvironment(this IContextAware contextAware)
{
ArgumentNullException.ThrowIfNull(contextAware);
// 获取上下文对象并返回其环境
var context = contextAware.GetContext();
return context.GetEnvironment();
}
/// <summary>
/// [Mediator] 发送命令的同步版本（不推荐,仅用于兼容性）
/// </summary>
/// <typeparam name="TResponse">命令响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令对象</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static TResponse SendCommand<TResponse>(this IContextAware contextAware,
Mediator.ICommand<TResponse> command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendCommand(command);
}
/// <summary>
/// 发送一个带返回结果的命令
/// </summary>
/// <typeparam name="TResult">命令执行结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static TResult SendCommand<TResult>(this IContextAware contextAware,
Abstractions.command.ICommand<TResult> command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendCommand(command);
}
/// <summary>
/// 发送一个无返回结果的命令
/// </summary>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static void SendCommand(this IContextAware contextAware, Abstractions.command.ICommand command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
context.SendCommand(command);
}
/// <summary>
/// [Mediator] 异步发送命令并返回结果
/// </summary>
/// <typeparam name="TResponse">命令响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令对象</param>
/// <param name="cancellationToken">取消令牌,用于取消操作</param>
/// <returns>包含命令执行结果的ValueTask</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static ValueTask<TResponse> SendCommandAsync<TResponse>(this IContextAware contextAware,
Mediator.ICommand<TResponse> command, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendCommandAsync(command, cancellationToken);
}
/// <summary>
/// 发送并异步执行一个无返回值的命令
/// </summary>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static async Task SendCommandAsync(this IContextAware contextAware, IAsyncCommand command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
await context.SendCommandAsync(command);
}
/// <summary>
/// 发送并异步执行一个带返回值的命令
/// </summary>
/// <typeparam name="TResult">命令执行结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static async Task<TResult> SendCommandAsync<TResult>(this IContextAware contextAware,
IAsyncCommand<TResult> command)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return await context.SendCommandAsync(command);
}
/// <summary>
/// [Mediator] 发送查询的同步版本（不推荐,仅用于兼容性）
/// </summary>
/// <typeparam name="TResponse">查询响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的查询对象</param>
/// <returns>查询结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static TResponse SendQuery<TResponse>(this IContextAware contextAware, Mediator.IQuery<TResponse> query)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return context.SendQuery(query);
}
/// <summary>
/// 发送一个查询请求
/// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的查询</param>
/// <returns>查询结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static TResult SendQuery<TResult>(this IContextAware contextAware, Abstractions.query.IQuery<TResult> query)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return context.SendQuery(query);
}
/// <summary>
/// [Mediator] 异步发送查询并返回结果
/// </summary>
/// <typeparam name="TResponse">查询响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的查询对象</param>
/// <param name="cancellationToken">取消令牌,用于取消操作</param>
/// <returns>包含查询结果的ValueTask</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static ValueTask<TResponse> SendQueryAsync<TResponse>(this IContextAware contextAware,
Mediator.IQuery<TResponse> query, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return context.SendQueryAsync(query, cancellationToken);
}
/// <summary>
/// 异步发送一个查询请求
/// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的异步查询</param>
/// <returns>查询结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static async Task<TResult> SendQueryAsync<TResult>(this IContextAware contextAware,
IAsyncQuery<TResult> query)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return await context.SendQueryAsync(query);
}
// === 统一请求处理方法 ===
/// <summary>
/// 发送请求（统一处理 Command/Query）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="request">要发送的请求</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>请求结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 request 为 null 时抛出</exception>
public static ValueTask<TResponse> SendRequestAsync<TResponse>(this IContextAware contextAware,
IRequest<TResponse> request, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(request);
var context = contextAware.GetContext();
return context.SendRequestAsync(request, cancellationToken);
}
/// <summary>
/// 发送请求（同步版本,不推荐）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="request">要发送的请求</param>
/// <returns>请求结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 request 为 null 时抛出</exception>
public static TResponse SendRequest<TResponse>(this IContextAware contextAware,
IRequest<TResponse> request)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(request);
var context = contextAware.GetContext();
return context.SendRequest(request);
}
/// <summary>
/// 发布通知（一对多事件）
/// </summary>
/// <typeparam name="TNotification">通知类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="notification">要发布的通知</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>异步任务</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 notification 为 null 时抛出</exception>
public static ValueTask PublishAsync<TNotification>(this IContextAware contextAware,
TNotification notification, CancellationToken cancellationToken = default)
where TNotification : INotification
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(notification);
var context = contextAware.GetContext();
return context.PublishAsync(notification, cancellationToken);
}
/// <summary>
/// 创建流式请求（用于大数据集）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="request">流式请求</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>异步响应流</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 request 为 null 时抛出</exception>
public static IAsyncEnumerable<TResponse> CreateStream<TResponse>(this IContextAware contextAware,
IStreamRequest<TResponse> request, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(request);
var context = contextAware.GetContext();
return context.CreateStream(request, cancellationToken);
}
// === 便捷扩展方法 ===
/// <summary>
/// 发送命令（无返回值）
/// </summary>
/// <typeparam name="TCommand">命令类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>异步任务</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static ValueTask SendAsync<TCommand>(this IContextAware contextAware, TCommand command,
CancellationToken cancellationToken = default)
where TCommand : IRequest<Unit>
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendAsync(command, cancellationToken);
}
/// <summary>
/// 发送命令（有返回值）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static ValueTask<TResponse> SendAsync<TResponse>(this IContextAware contextAware,
IRequest<TResponse> command, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendAsync(command, cancellationToken);
}
}

125
GFramework.Core/extensions/ContextAwareMediatorExtensions.cs Normal file
View File

@ -0,0 +1,125 @@
using GFramework.Core.Abstractions.rule;
using Mediator;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供对 IContextAware 接口的 Mediator 统一接口扩展方法
/// </summary>
public static class ContextAwareMediatorExtensions
{
/// <summary>
/// 发送请求（统一处理 Command/Query）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="request">要发送的请求</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>请求结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 request 为 null 时抛出</exception>
public static ValueTask<TResponse> SendRequestAsync<TResponse>(this IContextAware contextAware,
IRequest<TResponse> request, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(request);
var context = contextAware.GetContext();
return context.SendRequestAsync(request, cancellationToken);
}
/// <summary>
/// 发送请求（同步版本,不推荐）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="request">要发送的请求</param>
/// <returns>请求结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 request 为 null 时抛出</exception>
public static TResponse SendRequest<TResponse>(this IContextAware contextAware,
IRequest<TResponse> request)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(request);
var context = contextAware.GetContext();
return context.SendRequest(request);
}
/// <summary>
/// 发布通知（一对多事件）
/// </summary>
/// <typeparam name="TNotification">通知类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="notification">要发布的通知</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>异步任务</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 notification 为 null 时抛出</exception>
public static ValueTask PublishAsync<TNotification>(this IContextAware contextAware,
TNotification notification, CancellationToken cancellationToken = default)
where TNotification : INotification
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(notification);
var context = contextAware.GetContext();
return context.PublishAsync(notification, cancellationToken);
}
/// <summary>
/// 创建流式请求（用于大数据集）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="request">流式请求</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>异步响应流</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 request 为 null 时抛出</exception>
public static IAsyncEnumerable<TResponse> CreateStream<TResponse>(this IContextAware contextAware,
IStreamRequest<TResponse> request, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(request);
var context = contextAware.GetContext();
return context.CreateStream(request, cancellationToken);
}
/// <summary>
/// 发送命令（无返回值）
/// </summary>
/// <typeparam name="TCommand">命令类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>异步任务</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static ValueTask SendAsync<TCommand>(this IContextAware contextAware, TCommand command,
CancellationToken cancellationToken = default)
where TCommand : IRequest<Unit>
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendAsync(command, cancellationToken);
}
/// <summary>
/// 发送命令（有返回值）
/// </summary>
/// <typeparam name="TResponse">响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="command">要发送的命令</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns>命令执行结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 command 为 null 时抛出</exception>
public static ValueTask<TResponse> SendAsync<TResponse>(this IContextAware contextAware,
IRequest<TResponse> command, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(command);
var context = contextAware.GetContext();
return context.SendAsync(command, cancellationToken);
}
}

81
GFramework.Core/extensions/ContextAwareQueryExtensions.cs Normal file
View File

@ -0,0 +1,81 @@
using GFramework.Core.Abstractions.query;
using GFramework.Core.Abstractions.rule;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供对 IContextAware 接口的查询执行扩展方法
/// </summary>
public static class ContextAwareQueryExtensions
{
/// <summary>
/// [Mediator] 发送查询的同步版本（不推荐,仅用于兼容性）
/// </summary>
/// <typeparam name="TResponse">查询响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的查询对象</param>
/// <returns>查询结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static TResponse SendQuery<TResponse>(this IContextAware contextAware, Mediator.IQuery<TResponse> query)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return context.SendQuery(query);
}
/// <summary>
/// 发送一个查询请求
/// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的查询</param>
/// <returns>查询结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static TResult SendQuery<TResult>(this IContextAware contextAware, Abstractions.query.IQuery<TResult> query)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return context.SendQuery(query);
}
/// <summary>
/// [Mediator] 异步发送查询并返回结果
/// </summary>
/// <typeparam name="TResponse">查询响应类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的查询对象</param>
/// <param name="cancellationToken">取消令牌,用于取消操作</param>
/// <returns>包含查询结果的ValueTask</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static ValueTask<TResponse> SendQueryAsync<TResponse>(this IContextAware contextAware,
Mediator.IQuery<TResponse> query, CancellationToken cancellationToken = default)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return context.SendQueryAsync(query, cancellationToken);
}
/// <summary>
/// 异步发送一个查询请求
/// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <param name="query">要发送的异步查询</param>
/// <returns>查询结果</returns>
/// <exception cref="ArgumentNullException">当 contextAware 或 query 为 null 时抛出</exception>
public static async Task<TResult> SendQueryAsync<TResult>(this IContextAware contextAware,
IAsyncQuery<TResult> query)
{
ArgumentNullException.ThrowIfNull(contextAware);
ArgumentNullException.ThrowIfNull(query);
var context = contextAware.GetContext();
return await context.SendQueryAsync(query);
}
}

137
GFramework.Core/extensions/ContextAwareServiceExtensions.cs Normal file
View File

@ -0,0 +1,137 @@
using GFramework.Core.Abstractions.model;
using GFramework.Core.Abstractions.rule;
using GFramework.Core.Abstractions.system;
using GFramework.Core.Abstractions.utility;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供对 IContextAware 接口的服务访问扩展方法
/// 包含单例和批量获取服务、系统、模型、工具的方法
/// </summary>
public static class ContextAwareServiceExtensions
{
#region 单例获取
/// <summary>
/// 从上下文感知对象中获取指定类型的服务
/// </summary>
/// <typeparam name="TService">要获取的服务类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的上下文感知对象</param>
/// <returns>指定类型的服务实例,如果未找到则返回 null</returns>
/// <exception cref="ArgumentNullException">当 contextAware 参数为 null 时抛出</exception>
public static TService? GetService<TService>(this IContextAware contextAware) where TService : class
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetService<TService>();
}
/// <summary>
/// 获取架构上下文中的指定系统
/// </summary>
/// <typeparam name="TSystem">目标系统类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>指定类型的系统实例</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static TSystem? GetSystem<TSystem>(this IContextAware contextAware) where TSystem : class, ISystem
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetSystem<TSystem>();
}
/// <summary>
/// 获取架构上下文中的指定模型
/// </summary>
/// <typeparam name="TModel">目标模型类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>指定类型的模型实例</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static TModel? GetModel<TModel>(this IContextAware contextAware) where TModel : class, IModel
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetModel<TModel>();
}
/// <summary>
/// 获取架构上下文中的指定工具
/// </summary>
/// <typeparam name="TUtility">目标工具类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>指定类型的工具实例</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static TUtility? GetUtility<TUtility>(this IContextAware contextAware) where TUtility : class, IUtility
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetUtility<TUtility>();
}
#endregion
#region 批量获取
/// <summary>
/// 从上下文感知对象中获取指定类型的所有服务
/// </summary>
/// <typeparam name="TService">要获取的服务类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的上下文感知对象</param>
/// <returns>所有符合条件的服务实例列表</returns>
/// <exception cref="ArgumentNullException">当 contextAware 参数为 null 时抛出</exception>
public static IReadOnlyList<TService> GetServices<TService>(this IContextAware contextAware)
where TService : class
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetServices<TService>();
}
/// <summary>
/// 获取架构上下文中的所有指定系统
/// </summary>
/// <typeparam name="TSystem">目标系统类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>所有符合条件的系统实例列表</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static IReadOnlyList<TSystem> GetSystems<TSystem>(this IContextAware contextAware)
where TSystem : class, ISystem
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetSystems<TSystem>();
}
/// <summary>
/// 获取架构上下文中的所有指定模型
/// </summary>
/// <typeparam name="TModel">目标模型类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>所有符合条件的模型实例列表</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static IReadOnlyList<TModel> GetModels<TModel>(this IContextAware contextAware)
where TModel : class, IModel
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetModels<TModel>();
}
/// <summary>
/// 获取架构上下文中的所有指定工具
/// </summary>
/// <typeparam name="TUtility">目标工具类型</typeparam>
/// <param name="contextAware">实现 IContextAware 接口的对象</param>
/// <returns>所有符合条件的工具实例列表</returns>
/// <exception cref="ArgumentNullException">当 contextAware 为 null 时抛出</exception>
public static IReadOnlyList<TUtility> GetUtilities<TUtility>(this IContextAware contextAware)
where TUtility : class, IUtility
{
ArgumentNullException.ThrowIfNull(contextAware);
var context = contextAware.GetContext();
return context.GetUtilities<TUtility>();
}
#endregion
}