Euonia .NET 框架

// 五种策略，一种门面
var id1 = ObjectId.Snowflake();                    // Snowflake 64-bit → long
var id2 = ObjectId.Guid();                         // UUID (标准)
var id3 = ObjectId.Guid(GuidType.SequentialAsString);  // MySQL/PostgreSQL 顺序 GUID
var id4 = ObjectId.Guid(GuidType.SequentialAtEnd);     // SQL Server 顺序 GUID
var id5 = ObjectId.Random();                       // 随机字符串
var id6 = ObjectId.Ulid();                         // 字典序可排序 ULID

// 类型安全取值 — 隐式转换
long val = id1;                                    // 隐式转 long
Guid guid = id2;                                   // 隐式转 Guid
string str = id4;                                  // 隐式转 string

// ShortUniqueId — Hashids 风格编码
var encoded = ShortUniqueId.Default.Encode(12345);
var decoded = ShortUniqueId.Default.Decode(encoded);

var pool = new ObjectPool<MyClass>(policy);
var obj = pool.Lease();
// ... 使用 ...
pool.Return(obj);
// 默认大小为 Environment.ProcessorCount * 2，使用 Interlocked 无锁租用

// Unit — 替代 void，所有实例相等
public Task<Unit> DoSomethingAsync() => Task.FromResult(Unit.Value);

// Empty — 可序列化哨兵值
var sentinel = Empty.Value;

Check.EnsureNotNull(value, nameof(value));
Check.EnsureNotNullOrWhiteSpace(name, nameof(name));
Check.Ensure(length > 0, "长度必须大于0");
Check.EnsureIsMatch(email, @"^[\w.-]+@[\w.-]+\.[a-z]{2,}$", "邮箱格式错误");

// 流式校验
var result = Check.EnsureNotNull(value, "不能为空")
    .Then(v => Check.Ensure(v > 0, "必须大于0"));

// 表达式树驱动，编译时安全
var prop = Reflect<User>.GetProperty(u => u.Name);
var method = Reflect<User>.GetMethod(u => u.GetHashCode());
var value = Reflect<User>.GetValue(user, u => u.Name);
Reflect<User>.SetValue(user, u => u.Name, "新值");

// 类型转换
var coerced = TypeHelper.CoerceValue(typeof(int), typeof(string), 42); // "42"

// 方法调用器 — 动态编译表达式树
var invoker = MethodInvokerBuilder.Build(methodInfo);
var result = await invoker(instance, new object[] { arg1, arg2 });

// 无 DI 容器时的轻量替代
var instance = Singleton<MyService>.Instance;
var custom = Singleton<MyService>.Get(() => new MyService("config"));

// AsyncLock — 异步互斥锁
using (await asyncLock.LockAsync()) { /* 临界区 */ }

// AsyncMonitor — 异步监视器模式
using (await monitor.EnterAsync()) {
    await monitor.WaitAsync();      // 等待信号
    monitor.Pulse();                // 通知单个等待者
    monitor.PulseAll();             // 通知所有等待者
}

// AsyncLazy<T> — 异步延迟初始化
var lazy = new AsyncLazy<MyService>(() => CreateServiceAsync(),
    AsyncLazyFlags.ExecuteOnCallingThread | AsyncLazyFlags.RetryOnFailure);
var service = await lazy;

// 其他: AsyncSemaphore, AsyncAutoResetEvent, AsyncManualResetEvent,
//       AsyncCountdownEvent, AsyncProducerConsumerQueue<T>

// 拓扑排序
var sorted = list.SortByDependencies(x => x.Dependencies);

// 分页
var page = query.Paginate(pageNumber: 1, pageSize: 20);

// 随机打乱
var shuffled = list.Shuffle();

// 条件筛选
var filtered = query.WhereIf(condition, x => x.Status == active);

// 定义模块
[DependsOn(typeof(DomainModule), typeof(OsbaModule))]
public class MyBusinessModule : ModuleContextBase
{
    public override void ConfigureServices(IServiceCollection services)
    {
        // 自动注册 ITransientDependency / IScopedDependency / ISingletonDependency
    }
}

// 启动应用
var app = ApplicationFactory.Create<MyBusinessModule>();
app.Initialize(serviceProvider);

// 聚合根 — 内置领域事件管理
public class Order : Aggregate<long>
{
    public Money Total { get; private set; }
    public OrderStatus Status { get; private set; }

    public Order(long id)
    {
        Id = id;
        // 注册事件处理器
        Register<OrderCreatedEvent>(e => Status = OrderStatus.Created);
    }

    public void Create(Customer customer, Money total)
    {
        Total = total;
        // 触发事件（自动存储到事件列表）
        RaiseEvent(new OrderCreatedEvent(Id, total));
    }
}

// 命令 — 通过消息总线的 Unicast 分发
public class CreateOrderCommand : Command<CreateOrderData>
{
    // Command<TData> 提供 Data 属性，Command 提供 HashMap 式属性存储
}

// 命令响应
var response = new CommandResponse<OrderResult>();
response.Success().WithResult(orderResult);
response.Failure(ex).WithCode("ORDER_CREATE_FAILED");

public class Money : ValueObject<Money>
{
    public decimal Amount { get; }
    public string Currency { get; }

    // Equals / GetHashCode / == / != 自动基于所有 public 属性
}

// 声明属性（自动注册到 FieldDataManager）
[DisplayName("用户姓名")]
[Required(ErrorMessage = "姓名不能为空")]
private readonly PropertyInfo<string> _name = RegisterProperty<string>(nameof(Name));

// 类型安全的属性访问
public string Name
{
    get => ReadProperty(_name);
    set => SetProperty(_name, value);  // 追踪变更
}

// 标记为"已加载"（从持久层恢复时使用，不视为变更）
public void LoadName(string value) => LoadProperty(_name, value);

// BusinessContext 封装 IServiceProvider + UserPrincipal
var service = context.GetRequiredService<IMyService>();
var user = context.User;  // UserPrincipal (Id, Name, Code, Tenant, Roles)

// 编程式
using (var uow = manager.Begin(new UnitOfWorkOptions { IsTransactional = true }, false))
{
    uow.AddContext("db", efCoreContext);
    uow.AddContext("mq", rabbitMqContext);

    uow.Completed += (_, e) => Console.WriteLine($"UoW {e.UnitOfWork.Id} 完成");
    uow.Failed += (_, e) => Console.WriteLine($"UoW 失败: {e.Exception?.Message}");

    // ... 业务逻辑 ...

    await uow.CompleteAsync();  // SaveChanges → Commit → fire Completed
}

// 声明式 (AOP via Castle DynamicProxy)
[UnitOfWork(IsTransactional = true, IsolationLevel = IsolationLevel.ReadCommitted)]
public async Task<Order> CreateOrderAsync(CreateOrderCommand cmd) { ... }

Request → [Behavior 1] → [Behavior 2] → [Terminal] → Response
              ↑              ↑               ↑
          可以短路      可以转换响应       最终处理器

// 即发即忘
var pipeline = new DefaultPipelineProvider()
    .Use<LoggingBehavior>()
    .Use((ctx, next) => {
        Console.WriteLine($"Before: {ctx}");
        return next(ctx).ContinueWith(_ => Console.WriteLine($"After: {ctx}"));
    });
await pipeline.RunAsync("Hello");

// 类型化请求/响应
var pipeline = new DefaultPipelineProvider<CreateOrderCommand, OrderResult>();
pipeline.Use<ValidationBehavior<CreateOrderCommand, OrderResult>>();
pipeline.Use<AuthorizationBehavior<CreateOrderCommand, OrderResult>>();
var result = await pipeline.RunAsync(command, async cmd => {
    // 终端处理
    return await orderService.CreateAsync(cmd);
});

// 用例定义
public class CreateOrderUseCase : IUseCase<CreateOrderInput, OrderOutput>
{
    public async Task<OrderOutput> ExecuteAsync(CreateOrderInput input, CancellationToken cancellation)
    {
        // 业务逻辑
    }
}

// 用例呈现器
var presenter = new DefaultUseCasePresenter<OrderOutput>();
presenter.OnSucceed += (_, result) => Console.WriteLine($"成功: {result}");
presenter.OnFailed += (_, error) => Console.WriteLine($"失败: {error.Message}");

var useCase = new CreateOrderUseCase();
await useCase.ExecuteAsync(input, cancellation);

// 路径 A: [Subscribe] 特性
public class OrderHandler
{
    [Subscribe(Channel = "orders", Group = "processor")]
    public Task HandleAsync(CreateOrderCommand cmd, MessageContext ctx) { ... }
}

// 路径 B: IHandler<TMessage, TResponse> 接口
public class OrderHandler : IHandler<CreateOrderCommand>
{
    public Task<Unit> HandleAsync(CreateOrderCommand cmd, MessageContext ctx, CancellationToken ct) { ... }
}

// 零配置启动
public class Program
{
    public static Task Main(string[] args)
        => HostUtility.Run<StartupModule>(args, options =>
        {
            options.EnableHttp2 = true;
            options.ApplicationName = "MyApp";
        });
}

// 流式配置
var cache = CacheFactory.Build<MyData>(builder =>
{
    builder.WithDictionaryHandle()
           .WithExpiration(CacheExpirationMode.Sliding, TimeSpan.FromMinutes(5))
           .And
           .WithRedisCacheHandle("redis")
           .WithExpiration(CacheExpirationMode.Absolute, TimeSpan.FromHours(1));
});

// 使用
var value = await cache.GetOrAddAsync("key", async () => await LoadFromDbAsync());
await cache.PutAsync("key", newValue);
await cache.UpdateAsync("key", v => v with { Updated = DateTime.UtcNow });

// 定义实体
public class UserEntity : Entity<long>, IAuditable, IConcurrentEntity
{
    public string Name { get; set; }
    public string Email { get; set; }
}

// 仓储接口
public interface IUserRepository : IRepository<UserEntity, long>
{
    Task<UserEntity> FindByEmailAsync(string email);
}

// EF Core 实现
public class UserRepository : Repository<AppDbContext, UserEntity, long>, IUserRepository
{
    public async Task<UserEntity> FindByEmailAsync(string email)
        => await Queryable().FirstOrDefaultAsync(u => u.Email == email);
}

// 值对象
public class Money : ValueObject<Money>
{
    public decimal Amount { get; }
    public string Currency { get; }
}

// 聚合根
public class Order : Aggregate<long>
{
    public Money Total { get; private set; }
    public OrderStatus Status { get; private set; }

    public Order(long id)
    {
        Id = id;
        Register<OrderCreatedEvent>(e => Status = OrderStatus.Created);
    }

    public void Create(Customer customer, List<OrderLine> lines, Money total)
    {
        Total = total;
        RaiseEvent(new OrderCreatedEvent(Id, total));
    }
}

[Command]
[Channel("orders")]
public class CreateOrderCommand : Command<CreateOrderData>
{
    // Command<TData>.Data: CustomerId, Lines, Total
}

public class CreateOrderHandler : IHandler<CreateOrderCommand>
{
    private readonly IRepository<Order, long> _repository;
    private readonly IBus _bus;

    public async Task<Unit> HandleAsync(CreateOrderCommand cmd, MessageContext ctx, CancellationToken ct)
    {
        var order = new Order(ObjectId.Snowflake());
        order.Create(cmd.Data.CustomerId, cmd.Data.Lines, cmd.Data.Total);
        await _repository.InsertAsync(order);
        // 发布领域事件
        foreach (var e in order.GetEvents())
            await _bus.PublishAsync(e);
        await ctx.ResponseAsync(order.Id);
        return Unit.Value;
    }
}

// 流式 API
await bus.Send(new CreateOrderCommand(/*...*/))
    .AsChannel("orders")
    .ExecuteAsync();

// 请求-响应
var result = await bus.CallAsync<OrderResult>(new CreateOrderCommand(/*...*/));

[UnitOfWork(IsTransactional = true)]
public async Task<Unit> HandleAsync(CreateOrderCommand cmd, MessageContext ctx, CancellationToken ct)
{
    // 方法内的所有持久化操作在同一个事务中
}

<!-- 核心工具（必选） -->
<PackageReference Include="Euonia.Core" Version="2026.3.2" />

var pipeline = new DefaultPipelineProvider()
    .Use((ctx, next) =>
    {
        Console.WriteLine($"Before: {ctx}");
        return next(ctx).ContinueWith(_ => Console.WriteLine($"After: {ctx}"));
    });
await pipeline.RunAsync("Hello, Pipeline!");

// 配置
var services = new ServiceCollection();
services.AddEuoniaBus(builder =>
{
    builder.AddConvention()
           .Evaluate(c => c.IsAssignableTo<IQueue>(), MessageConventionType.Unicast)
           .Evaluate(c => c.IsAssignableTo<ITopic>(), MessageConventionType.Multicast);
    builder.AddHandlers(typeof(OrderHandler).Assembly);
});

// 发送
var bus = serviceProvider.GetRequiredService<IBus>();
await bus.Send(new CreateOrderCommand(/*...*/)).ExecuteAsync();

// Program.cs
public static Task Main(string[] args)
    => HostUtility.Run<StartupModule>(args);

// StartupModule.cs
[DependsOn(
    typeof(HostingModule),
    typeof(ApplicationModule),
    typeof(DomainModule),
    typeof(OsbaModule),
    typeof(MessageBusModule)
)]
public class StartupModule : ModuleContextBase
{
    public override void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        services.AddJwtAuthentication(Configuration.GetSection("Jwt"));
    }
}

// 应用服务
public class OrderService : BaseApplicationService, IApplicationService
{
    public async Task CreateOrderAsync(CreateOrderDto dto)
    {
        // Bus 通过 BaseApplicationService 自动注入
        await Bus.Send(new CreateOrderCommand(/*...*/)).ExecuteAsync();
    }
}