如何借助Entity Framework与仓储模式避免记录重复插入？

要避免数据库中出现重复记录，核心逻辑是先判断实体是否已存在，再决定是否执行添加操作。以下是几种适配泛型仓储模式的实现方式：

方式一：让实体实现统一标识接口（可控性强） #

先定义一个约定唯一标识的接口，让所有需要去重的实体实现它：

public interface IHasUniqueKey
{
    // 可根据业务返回单个主键，或复合键（比如值元组、匿名对象）
    object GetUniqueKey();
}

修改泛型仓储，限制T实现该接口，并新增带去重逻辑的添加方法：

public class GenericRepository<T> : IGenericRepository<T> where T : class, IHasUniqueKey
{
    private readonly ApplicationDBContext _context;        
    protected DbSet<T> dbSet;

    public GenericRepository(ApplicationDBContext context)
    {
        this._context = context;
        this.dbSet = context.Set<T>();
    }

    public virtual async Task<bool> AddIfNotExists(T entity)
    {
        var uniqueKey = entity.GetUniqueKey();
        // 检查数据库中是否存在相同唯一键的记录
        var exists = await dbSet.AnyAsync(e => e.GetUniqueKey().Equals(uniqueKey));
        
        if (!exists)
        {
            await dbSet.AddAsync(entity);
            return true;
        }
        return false;
    }
}

如果是复合主键的实体，可通过值元组返回组合键：

public class UserRole : IHasUniqueKey
{
    public int UserId { get; set; }
    public int RoleId { get; set; }

    public object GetUniqueKey()
    {
        return (UserId, RoleId); // 值元组支持Equals比较
    }
}

方式二：利用EF Core元数据自动识别主键（无需修改实体） #

如果不想修改实体代码，可以通过EF Core的模型元数据自动获取主键属性，实现通用去重：

public class GenericRepository<T> : IGenericRepository<T> where T : class
{
    private readonly ApplicationDBContext _context;        
    protected DbSet<T> dbSet;
    private readonly PropertyInfo[] _keyProperties;

    public GenericRepository(ApplicationDBContext context)
    {
        this._context = context;
        this.dbSet = context.Set<T>();
        // 从EF模型中获取当前实体的主键属性
        _keyProperties = _context.Model.FindEntityType(typeof(T))
            .FindPrimaryKey()
            .Properties
            .Select(p => typeof(T).GetProperty(p.Name))
            .ToArray();
    }

    public virtual async Task<bool> AddIfNotExists(T entity)
    {
        // 动态构建查询条件：对比所有主键属性的值
        var parameter = Expression.Parameter(typeof(T), "e");
        var conditions = _keyProperties.Select(keyProp =>
            Expression.Equal(
                Expression.Property(parameter, keyProp),
                Expression.Constant(keyProp.GetValue(entity))
            ));
        var combinedCondition = conditions.Aggregate(Expression.AndAlso);
        var existsPredicate = Expression.Lambda<Func<T, bool>>(combinedCondition, parameter);

        var exists = await dbSet.AnyAsync(existsPredicate);
        
        if (!exists)
        {
            await dbSet.AddAsync(entity);
            return true;
        }
        return false;
    }
}

批量处理优化（适配API返回全量数据的场景） #

因为API每次返回全部数据，单个处理效率较低，建议实现批量去重添加：

public virtual async Task<int> AddRangeIfNotExists(IEnumerable<T> entities)
{
    if (!entities.Any()) return 0;

    // 提取所有待添加实体的主键值集合
    var keyValues = entities.Select(entity =>
        _keyProperties.Select(prop => prop.GetValue(entity)).ToArray()
    ).ToList();

    // 查询数据库中已存在的主键
    var existingKeys = await dbSet.Select(e =>
        _keyProperties.Select(prop => prop.GetValue(e)).ToArray()
    ).ToListAsync();

    // 筛选出不存在的实体
    var entitiesToAdd = entities.Where(entity =>
    {
        var entityKey = _keyProperties.Select(prop => prop.GetValue(entity)).ToArray();
        return !existingKeys.Any(existing => 
            existing.Zip(entityKey, (a, b) => Equals(a, b)).All(x => x)
        );
    }).ToList();

    if (entitiesToAdd.Any())
    {
        await dbSet.AddRangeAsync(entitiesToAdd);
        return entitiesToAdd.Count;
    }
    return 0;
}

关键注意事项 #

• 事务与提交时机：建议仓储层只负责添加实体，由上层业务逻辑统一调用_context.SaveChangesAsync()，合并事务提升效率。
• 并发冲突处理：如果存在多进程写入场景，需在数据库主键上添加唯一约束，同时捕获EF的DbUpdateException处理插入冲突。
• 大数据量优化：若数据量极大，批量处理时可分页查询已存在的主键，避免内存过载。

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