EF Core事务内是否有属性可标识已产生变更？

核心思路 #

IDbContextTransaction本身没有内置变更跟踪能力，而DbContext.ChangeTracker是上下文级的（会包含所有未提交变更，不限于当前事务）。因此我们需要：

1. 在事务开启前，记录ChangeTracker的初始状态快照
2. 通过对比当前ChangeTracker状态与快照，判断事务期间是否产生专属变更
3. 结合Blazor组件生命周期和JS互操作，拦截页面退出/导航操作并触发询问

实现步骤 #

1. 定义实体状态快照类 #

用于保存事务开启时实体的状态和原始值，供后续对比使用：

public class EntityStateSnapshot
{
    public EntityState OriginalState { get; set; }
    public Dictionary<string, object> OriginalValues { get; set; } = new();
}

2. 组件内事务管理与快照记录 #

在Razor组件中注入依赖并声明事务、快照对象：

@inject YourDbContext DbContext
@inject IJSRuntime JSRuntime
@inject NavigationManager NavManager
@implements IDisposable

@code {
    private IDbContextTransaction? _activeTransaction;
    private Dictionary<object, EntityStateSnapshot> _transactionStartSnapshot = new();
    private DotNetObjectReference<YourComponent>? _componentRef;

    // 开启事务并记录初始状态快照
    private async Task StartTransaction()
    {
        // 捕获当前ChangeTracker中所有实体的状态
        foreach (var entry in DbContext.ChangeTracker.Entries())
        {
            _transactionStartSnapshot[entry.Entity] = new EntityStateSnapshot
            {
                OriginalState = entry.State,
                OriginalValues = entry.CurrentValues.Clone().ToDictionary()
            };
        }
        // 开启数据库事务
        _activeTransaction = await DbContext.Database.BeginTransactionAsync();
    }
}

3. 事务级变更检测方法 #

通过对比当前状态与快照，判断事务内是否产生有效变更：

private bool HasTransactionLevelChanges()
{
    if (_activeTransaction == null) return false;

    foreach (var entry in DbContext.ChangeTracker.Entries())
    {
        // 事务期间新增的实体（不在快照中）
        if (!_transactionStartSnapshot.TryGetValue(entry.Entity, out var snapshot))
        {
            if (entry.State != EntityState.Detached)
                return true;
        }
        else
        {
            // 实体状态发生变化
            if (entry.State != snapshot.OriginalState)
                return true;
            
            // 状态为Modified时，对比属性值是否变更
            if (entry.State == EntityState.Modified)
            {
                var currentValues = entry.CurrentValues.ToDictionary();
                foreach (var (key, originalValue) in snapshot.OriginalValues)
                {
                    if (!currentValues.TryGetValue(key, out var currentValue) || 
                        !Equals(originalValue, currentValue))
                    {
                        return true;
                    }
                }
            }
        }
    }
    return false;
}

4. 拦截页面退出/导航操作 #

处理页面刷新/关闭（JS互操作）

在wwwroot/js中添加脚本：

window.registerBeforeUnloadCheck = (callback) => {
    window.addEventListener('beforeunload', (event) => {
        const hasUnsavedChanges = callback.invokeMethod('HasTransactionLevelChanges');
        if (hasUnsavedChanges) {
            event.preventDefault();
            event.returnValue = ''; // 兼容各浏览器提示文案
            return '';
        }
    });
};

window.unregisterBeforeUnloadCheck = () => {
    window.removeEventListener('beforeunload', null);
};

在组件中注册/注销事件：

protected override async Task OnAfterRenderAsync(bool firstRender)
{
    if (firstRender)
    {
        _componentRef = DotNetObjectReference.Create(this);
        await JSRuntime.InvokeVoidAsync("registerBeforeUnloadCheck", _componentRef);
    }
    await base.OnAfterRenderAsync(firstRender);
}

处理客户端路由导航

拦截NavigationManager的路由变化事件：

protected override void OnInitialized()
{
    NavManager.LocationChanged += HandleLocationChanged;
    base.OnInitialized();
}

private async void HandleLocationChanged(object? sender, LocationChangedEventArgs e)
{
    if (!HasTransactionLevelChanges()) return;

    // 阻止默认导航，先处理事务
    NavManager.NavigateTo(NavManager.Uri, forceLoad: false);
    
    var shouldCommit = await JSRuntime.InvokeAsync<bool>("confirm", "您有未提交的事务变更，是否提交？");
    if (shouldCommit)
    {
        await _activeTransaction!.CommitAsync();
    }
    else
    {
        await RollbackTransactionAndResetState();
    }

    // 清理事务后执行导航
    _activeTransaction?.Dispose();
    _activeTransaction = null;
    _transactionStartSnapshot.Clear();
    NavManager.NavigateTo(e.Location, forceLoad: false);
}

5. 事务提交与回滚逻辑 #

private async Task CommitTransaction()
{
    if (_activeTransaction == null) return;
    
    await _activeTransaction.CommitAsync();
    _activeTransaction.Dispose();
    _activeTransaction = null;
    _transactionStartSnapshot.Clear();
}

private async Task RollbackTransactionAndResetState()
{
    if (_activeTransaction == null) return;
    
    await _activeTransaction.RollbackAsync();
    _activeTransaction.Dispose();
    _activeTransaction = null;

    // 将ChangeTracker恢复到事务开启前的状态
    foreach (var entry in DbContext.ChangeTracker.Entries())
    {
        if (_transactionStartSnapshot.TryGetValue(entry.Entity, out var snapshot))
        {
            entry.State = snapshot.OriginalState;
            if (snapshot.OriginalState != EntityState.Added)
            {
                entry.CurrentValues.SetValues(snapshot.OriginalValues);
            }
        }
        else
        {
            // 事务期间新增的实体，从上下文分离
            entry.State = EntityState.Detached;
        }
    }
    _transactionStartSnapshot.Clear();
}

6. 组件资源清理 #

实现IDisposable接口清理资源：

public void Dispose()
{
    _componentRef?.Dispose();
    _activeTransaction?.Dispose();
    NavManager.LocationChanged -= HandleLocationChanged;
    JSRuntime.InvokeVoidAsync("unregisterBeforeUnloadCheck");
}

注意事项 #

• 确保每个事务开启时都正确记录快照，避免跨事务变更干扰
• 回滚事务后必须重置ChangeTracker状态，避免残留变更影响后续操作
• 客户端导航拦截需先阻止默认行为，处理完事务后再执行导航

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