ASP.NET Core中基于多实体控制器实现实体变更历史的方案问询

针对你在ASP.NET Core中给多个类似EntityController的控制器实现实体变更历史的需求，我整理了几个实用的方案，你可以根据自己的业务场景选择：

方案1：动作过滤器（Action Filter） #

这个方案通过自定义Action Filter拦截控制器的更新动作，在执行前后获取实体的新旧状态，记录变更历史。好处是不用修改现有控制器的业务逻辑，实现关注点分离。

步骤实现： #

1. 定义变更历史实体

public class EntityChangeHistory
{
    public int Id { get; set; }
    public string EntityType { get; set; } // 实体类型名称，比如"Entity"
    public int EntityId { get; set; } // 实体ID
    public string ChangedBy { get; set; } // 操作人
    public DateTime ChangeTime { get; set; } // 操作时间
    public string OldValue { get; set; } // 变更前的JSON序列化内容
    public string NewValue { get; set; } // 变更后的JSON序列化内容
}

2. 实现自定义Action Filter

public class TrackEntityChangesAttribute : ActionFilterAttribute
{
    private readonly IEntityChangeHistoryRepository _historyRepo;
    private readonly IHttpContextAccessor _httpContextAccessor;

    // 通过构造注入获取依赖
    public TrackEntityChangesAttribute(IEntityChangeHistoryRepository historyRepo, IHttpContextAccessor httpContextAccessor)
    {
        _historyRepo = historyRepo;
        _httpContextAccessor = httpContextAccessor;
    }

    public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        // 从Action参数中提取ID和传入的新实体
        if (!context.ActionArguments.TryGetValue("id", out var idObj) || 
            !context.ActionArguments.TryGetValue("entity", out var newEntity))
        {
            await next();
            return;
        }

        var entityId = Convert.ToInt32(idObj);
        var entityType = newEntity.GetType();

        // 获取原始实体（这里假设你有泛型仓储，通过DI容器获取对应仓储实例）
        var repoType = typeof(IRepository<>).MakeGenericType(entityType);
        var repo = context.HttpContext.RequestServices.GetService(repoType);
        var getByIdMethod = repoType.GetMethod("GetByIdAsync");
        var oldEntity = await (Task<object>)getByIdMethod.Invoke(repo, new object[] { entityId });

        // 执行原控制器动作
        var resultContext = await next();

        // 仅当动作执行成功（返回OkResult）时记录历史
        if (resultContext.Result is OkObjectResult okResult && okResult.Value != null)
        {
            var updatedEntity = okResult.Value;
            var currentUser = _httpContextAccessor.HttpContext.User.Identity.Name ?? "Anonymous";

            // 序列化新旧实体（如果需要更精细的字段差异，可以用DeepDiff等库对比）
            var oldValueJson = JsonSerializer.Serialize(oldEntity);
            var newValueJson = JsonSerializer.Serialize(updatedEntity);

            var historyRecord = new EntityChangeHistory
            {
                EntityType = entityType.Name,
                EntityId = entityId,
                ChangedBy = currentUser,
                ChangeTime = DateTime.UtcNow,
                OldValue = oldValueJson,
                NewValue = newValueJson
            };

            await _historyRepo.AddAsync(historyRecord);
            await _historyRepo.SaveChangesAsync();
        }
    }
}

3. 注册服务并使用过滤器
   在Program.cs中注册相关服务：

builder.Services.AddScoped<IEntityChangeHistoryRepository, EntityChangeHistoryRepository>();
builder.Services.AddScoped<TrackEntityChangesAttribute>();
builder.Services.AddHttpContextAccessor(); // 用于获取当前用户

然后在控制器的Put方法上添加过滤器：

[Authorize]
[HttpPut("{id}")]
[TrackEntityChanges] // 新增这个特性
public async ValueTask<IActionResult> Put(int id, [FromBody] Entity entity) {
    // 原有逻辑不变
}

优点：不侵入业务代码，仅针对指定控制器动作生效；缺点：需要处理泛型仓储的反射调用，全量序列化会占用更多存储。

方案2：仓储层装饰器（Repository Decorator） #

如果希望所有调用仓储Update方法的地方（包括控制器、服务层）都自动记录变更历史，可以用装饰器模式包装你的仓储实现。

步骤实现： #

1. 定义泛型装饰器

public class RepositoryWithHistoryDecorator<T> : IEntityRepository<T> where T : class, IEntity // 假设你的实体都实现了IEntity接口（包含Id属性）
{
    private readonly IEntityRepository<T> _originalRepo;
    private readonly IEntityChangeHistoryRepository _historyRepo;
    private readonly IHttpContextAccessor _httpContextAccessor;

    public RepositoryWithHistoryDecorator(IEntityRepository<T> originalRepo, IEntityChangeHistoryRepository historyRepo, IHttpContextAccessor httpContextAccessor)
    {
        _originalRepo = originalRepo;
        _historyRepo = historyRepo;
        _httpContextAccessor = httpContextAccessor;
    }

    public async Task<T> Update(T entity)
    {
        // 获取原始实体
        var oldEntity = await _originalRepo.GetByIdAsync(entity.Id);
        var updatedEntity = await _originalRepo.Update(entity);

        if (updatedEntity != null)
        {
            var currentUser = _httpContextAccessor.HttpContext.User.Identity.Name ?? "System";
            var oldValueJson = JsonSerializer.Serialize(oldEntity);
            var newValueJson = JsonSerializer.Serialize(updatedEntity);

            var historyRecord = new EntityChangeHistory
            {
                EntityType = typeof(T).Name,
                EntityId = entity.Id,
                ChangedBy = currentUser,
                ChangeTime = DateTime.UtcNow,
                OldValue = oldValueJson,
                NewValue = newValueJson
            };

            await _historyRepo.AddAsync(historyRecord);
            await _historyRepo.SaveChangesAsync();
        }

        return updatedEntity;
    }

    // 代理其他仓储方法，直接调用原始仓储
    public async Task<T> GetByIdAsync(int id) => await _originalRepo.GetByIdAsync(id);
    // 实现IEntityRepository的其他方法...
}

2. 注册装饰器
   在Program.cs中用装饰器替换原始仓储注册：

// 先注册原始仓储
builder.Services.AddScoped<IEntityRepository<Entity>, EntityRepository>();
// 用装饰器包装
builder.Services.Decorate<IEntityRepository<Entity>, RepositoryWithHistoryDecorator<Entity>>();

// 注册其他依赖
builder.Services.AddScoped<IEntityChangeHistoryRepository, EntityChangeHistoryRepository>();
builder.Services.AddHttpContextAccessor();

优点：覆盖所有仓储调用场景，无需修改控制器；缺点：需要为每个实体仓储配置装饰器（或用泛型批量处理），如果仓储接口方法较多，需要全部代理。

方案3：EF Core ChangeTracker拦截 #

如果你的项目用EF Core作为ORM，可以通过重写DbContext的SaveChangesAsync方法，全局追踪所有实体的修改操作，无需修改控制器和仓储。

步骤实现： #

1. 重写DbContext的SaveChangesAsync

public class AppDbContext : DbContext
{
    private readonly IEntityChangeHistoryRepository _historyRepo;
    private readonly IHttpContextAccessor _httpContextAccessor;

    public AppDbContext(DbContextOptions<AppDbContext> options, IEntityChangeHistoryRepository historyRepo, IHttpContextAccessor httpContextAccessor)
        : base(options)
    {
        _historyRepo = historyRepo;
        _httpContextAccessor = httpContextAccessor;
    }

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        var currentUser = _httpContextAccessor.HttpContext?.User?.Identity?.Name ?? "Anonymous";
        var changeTime = DateTime.UtcNow;

        // 获取所有被修改的实体
        var modifiedEntries = ChangeTracker.Entries()
            .Where(e => e.State == EntityState.Modified)
            .ToList();

        foreach (var entry in modifiedEntries)
        {
            var entityType = entry.Entity.GetType().Name;
            var entityId = (int)entry.OriginalValues["Id"]; // 假设实体都有Id属性

            // 序列化原始值和当前值
            var oldValueJson = JsonSerializer.Serialize(entry.OriginalValues.ToObject());
            var newValueJson = JsonSerializer.Serialize(entry.CurrentValues.ToObject());

            var historyRecord = new EntityChangeHistory
            {
                EntityType = entityType,
                EntityId = entityId,
                ChangedBy = currentUser,
                ChangeTime = changeTime,
                OldValue = oldValueJson,
                NewValue = newValueJson
            };

            await _historyRepo.AddAsync(historyRecord);
        }

        // 先保存实体变更，再保存历史记录（建议用事务包裹，确保原子性）
        using var transaction = await Database.BeginTransactionAsync(cancellationToken);
        try
        {
            var saveResult = await base.SaveChangesAsync(cancellationToken);
            await _historyRepo.SaveChangesAsync(cancellationToken);
            await transaction.CommitAsync(cancellationToken);
            return saveResult;
        }
        catch
        {
            await transaction.RollbackAsync(cancellationToken);
            throw;
        }
    }
}

2. 注册服务
   确保IEntityChangeHistoryRepository和IHttpContextAccessor已注册，DbContext会自动注入这些依赖。

优点：全局自动追踪所有EF Core的实体修改，完全无侵入；缺点：无法追踪非EF Core的变更（比如直接SQL操作），全量序列化存储成本较高。

额外优化建议 #

• 记录字段级差异：不要全量序列化实体，用反射或第三方库（如DeepDiff.NET）对比新旧实体的属性值，只记录变化的字段，减少存储占用。
• 敏感字段过滤：对于密码、手机号等敏感字段，在序列化时跳过或加密存储。
• 异步处理：如果记录历史的操作影响主业务性能，可以将历史记录写入消息队列，异步消费保存，减少主请求的响应时间。
• 事务保障：确保实体变更和历史记录的操作在同一个事务中，避免数据不一致。

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