如何使用EF Core实现员工与班次数据的快照备份与恢复

单数据库方案（推荐） #

1. 设计快照相关实体 #

新增三个实体存储快照元数据与快照副本：

• SnapshotMetadata：记录快照的基础信息（时间、描述等）
• EmployeeSnapshot：保存对应快照下的员工数据副本
• ShiftSnapshot：保存对应快照下的班次数据副本

代码示例：

// 快照元数据实体
public class SnapshotMetadata
{
    public int Id { get; set; }
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    public string? Description { get; set; } // 可选，用户自定义备份描述

    // 关联快照下的员工、班次数据
    public ICollection<EmployeeSnapshot> EmployeeSnapshots { get; set; } = new List<EmployeeSnapshot>();
    public ICollection<ShiftSnapshot> ShiftSnapshots { get; set; } = new List<ShiftSnapshot>();
}

// 员工快照实体（复制原Employee所有业务字段，新增快照关联ID）
public class EmployeeSnapshot
{
    public int Id { get; set; }
    // 复制原Employee的业务字段，示例：
    public string Name { get; set; } = string.Empty;
    public string Position { get; set; } = string.Empty;
    // ...其他原Employee字段

    public int SnapshotMetadataId { get; set; }
    public SnapshotMetadata SnapshotMetadata { get; set; } = null!;
}

// 班次快照实体（复制原Shift所有业务字段，新增快照关联ID）
public class ShiftSnapshot
{
    public int Id { get; set; }
    // 复制原Shift的业务字段，示例：
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
    public int EmployeeId { get; set; } // 存储快照时的员工ID，恢复时需匹配
    // ...其他原Shift字段

    public int SnapshotMetadataId { get; set; }
    public SnapshotMetadata SnapshotMetadata { get; set; } = null!;
}

2. 更新主DbContext #

在现有DbContext中添加快照相关的DbSet，并配置实体关系：

public class AppDbContext : DbContext
{
    // 原有业务DbSet
    public DbSet<Employee> Employees { get; set; } = null!;
    public DbSet<Shift> Shifts { get; set; } = null!;
    // ...其他业务DbSet

    // 新增快照相关DbSet
    public DbSet<SnapshotMetadata> SnapshotMetadatas { get; set; } = null!;
    public DbSet<EmployeeSnapshot> EmployeeSnapshots { get; set; } = null!;
    public DbSet<ShiftSnapshot> ShiftSnapshots { get; set; } = null!;

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // 配置快照数据与元数据的级联删除关系
        modelBuilder.Entity<EmployeeSnapshot>()
            .HasOne(s => s.SnapshotMetadata)
            .WithMany(m => m.EmployeeSnapshots)
            .HasForeignKey(s => s.SnapshotMetadataId)
            .OnDelete(DeleteBehavior.Cascade);

        modelBuilder.Entity<ShiftSnapshot>()
            .HasOne(s => s.SnapshotMetadata)
            .WithMany(m => m.ShiftSnapshots)
            .HasForeignKey(s => s.SnapshotMetadataId)
            .OnDelete(DeleteBehavior.Cascade);
    }
}

3. 实现创建快照逻辑 #

用事务保证快照数据的一致性：

public async Task<int> CreateSnapshotAsync(AppDbContext context, string? description = null)
{
    using var transaction = await context.Database.BeginTransactionAsync();
    try
    {
        // 生成快照元数据
        var metadata = new SnapshotMetadata
        {
            Description = description,
            CreatedAt = DateTime.UtcNow
        };
        context.SnapshotMetadatas.Add(metadata);
        await context.SaveChangesAsync();

        // 复制当前员工数据到快照表
        var employees = await context.Employees.ToListAsync();
        var employeeSnapshots = employees.Select(e => new EmployeeSnapshot
        {
            SnapshotMetadataId = metadata.Id,
            Name = e.Name,
            Position = e.Position,
            // ...映射其他原Employee字段
        }).ToList();
        context.EmployeeSnapshots.AddRange(employeeSnapshots);

        // 复制当前班次数据到快照表
        var shifts = await context.Shifts.ToListAsync();
        var shiftSnapshots = shifts.Select(s => new ShiftSnapshot
        {
            SnapshotMetadataId = metadata.Id,
            StartTime = s.StartTime,
            EndTime = s.EndTime,
            EmployeeId = s.EmployeeId,
            // ...映射其他原Shift字段
        }).ToList();
        context.ShiftSnapshots.AddRange(shiftSnapshots);

        await context.SaveChangesAsync();
        await transaction.CommitAsync();

        return metadata.Id;
    }
    catch
    {
        await transaction.RollbackAsync();
        throw;
    }
}

4. 实现恢复快照逻辑 #

同样用事务保证恢复操作的原子性：

public async Task RestoreSnapshotAsync(AppDbContext context, int snapshotId)
{
    using var transaction = await context.Database.BeginTransactionAsync();
    try
    {
        // 获取指定快照的完整数据
        var snapshot = await context.SnapshotMetadatas
            .Include(m => m.EmployeeSnapshots)
            .Include(m => m.ShiftSnapshots)
            .FirstOrDefaultAsync(m => m.Id == snapshotId);

        if (snapshot == null)
            throw new ArgumentException("指定快照不存在");

        // 批量清空当前员工、班次数据（EF Core 6+ ExecuteDelete效率远高于逐条删除）
        await context.Employees.ExecuteDeleteAsync();
        await context.Shifts.ExecuteDeleteAsync();

        // 将快照数据恢复到原业务表
        var restoredEmployees = snapshot.EmployeeSnapshots.Select(s => new Employee
        {
            Name = s.Name,
            Position = s.Position,
            // ...映射其他字段
        }).ToList();
        context.Employees.AddRange(restoredEmployees);

        var restoredShifts = snapshot.ShiftSnapshots.Select(s => new Shift
        {
            StartTime = s.StartTime,
            EndTime = s.EndTime,
            EmployeeId = s.EmployeeId,
            // ...映射其他字段
        }).ToList();
        context.Shifts.AddRange(restoredShifts);

        await context.SaveChangesAsync();
        await transaction.CommitAsync();
    }
    catch
    {
        await transaction.RollbackAsync();
        throw;
    }
}

关键注意事项 #

• 自增主键适配：如果原Employee用自增ID，恢复时新插入的员工ID会重新生成，导致Shift的EmployeeId不匹配。解决方式：
  1. 改用业务主键（如员工编号）替代自增ID；
  2. 在EmployeeSnapshot中保留原员工ID，恢复时手动指定ID（需临时开启PostgreSQL的IDENTITY_INSERT）。
• 性能优化：数据量较大时，使用批量操作（AddRange/ExecuteDelete），也可引入Npgsql批量操作扩展提升效率。
• 快照清理：定期删除过期快照，避免数据库膨胀。

多数据库方案 #

如果单库快照影响主库性能，可单独创建备份数据库：

1. 搭建与主库结构一致的备份库（仅保留Employees、Shifts、SnapshotMetadata相关表）；
2. 配置两个DbContext：主库AppDbContext、备份库BackupDbContext；
3. 创建快照时，从主库读取数据写入备份库并记录元数据；
4. 恢复时，从备份库读取指定快照数据，覆盖主库对应表。

该方案优势是快照数据不占用主库资源，但需额外维护数据库连接与结构同步。

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