如何在EF Core（CosmosDB）中统一为AggregateRoot实体保存领域事件？

一、统一配置所有AggregateRoot的领域事件序列化 #

针对你提到的无法在ConfigureConventions中传递TypeInfoResolver的问题，可以通过在OnModelCreating中遍历所有继承自AggregateRoot的实体，统一应用序列化配置，无需逐个写EntityTypeConfiguration：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 筛选所有AggregateRoot派生实体
    var aggregateRootTypes = modelBuilder.Model.GetEntityTypes()
        .Where(t => typeof(AggregateRoot).IsAssignableFrom(t.ClrType));

    foreach (var entityType in aggregateRootTypes)
    {
        modelBuilder.Entity(entityType.ClrType)
            .Property(nameof(AggregateRoot.DomainEvents))
            .HasConversion(
                serialize: events => JsonSerializer.Serialize(events, new JsonSerializerOptions
                {
                    TypeInfoResolver = new CustomEventTypeResolver(),
                    WriteIndented = false
                }),
                deserialize: json => JsonSerializer.Deserialize<List<IDomainEvent>>(json, new JsonSerializerOptions
                {
                    TypeInfoResolver = new CustomEventTypeResolver()
                }) ?? new List<IDomainEvent>()
            )
            .IsRequired(false);
    }

    // 其他实体配置...
}

二、独立Outbox集合+SaveChanges拦截（更推荐的Outbox实现） #

将领域事件与实体分离存储到独立的OutboxMessage集合，通过重写SaveChanges自动提取并保存事件，利用CosmosDB同一容器内的事务特性保证一致性：

1. 定义OutboxMessage实体 #

public class OutboxMessage
{
    public Guid Id { get; set; }
    public string EventType { get; set; }
    public string EventData { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
    public bool IsPublished { get; set; }
}

2. 在DbContext中注册并配置 #

public DbSet<OutboxMessage> OutboxMessages { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 配置OutboxMessage的CosmosDB属性（比如分区键）
    modelBuilder.Entity<OutboxMessage>()
        .ToContainer("OutboxMessages")
        .HasPartitionKey(m => m.Id);

    // 其他配置...
}

3. 重写SaveChanges自动处理领域事件 #

public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
    ProcessDomainEvents();
    return base.SaveChanges(acceptAllChangesOnSuccess);
}

public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
{
    ProcessDomainEvents();
    return await base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
}

private void ProcessDomainEvents()
{
    // 提取所有已修改的AggregateRoot中的领域事件
    var aggregateRoots = ChangeTracker.Entries<AggregateRoot>()
        .Where(e => e.Entity.DomainEvents.Any())
        .ToList();

    foreach (var entry in aggregateRoots)
    {
        var events = entry.Entity.DomainEvents.ToList();
        entry.Entity.ClearDomainEvents(); // 清空实体的事件集合，避免重复保存

        foreach (var domainEvent in events)
        {
            var outboxMessage = new OutboxMessage
            {
                Id = Guid.NewGuid(),
                EventType = domainEvent.GetType().FullName,
                EventData = JsonSerializer.Serialize(domainEvent, new JsonSerializerOptions
                {
                    TypeInfoResolver = new CustomEventTypeResolver()
                }),
                CreatedAt = DateTimeOffset.UtcNow,
                IsPublished = false
            };

            Add(outboxMessage);
        }
    }
}

三、跨容器场景的补充方案 #

如果实体和OutboxMessage需要放在不同容器，EF Core不支持跨容器事务，此时可以直接使用CosmosDB SDK的TransactionalBatch手动实现原子操作：

1. 从EF Core的ChangeTracker中提取待保存/更新的实体，转换为CosmosDB SDK的操作对象；
2. 构建TransactionalBatch，添加实体操作和OutboxMessage创建操作；
3. 执行Batch后，手动更新EF CoreChangeTracker的实体状态，确保上下文状态一致。

内容的提问来源于stack exchange，提问作者Phil Golding