如何处理通用存储库中的数据库事务？

Question

我正在使用 ASP.NET Core WebAPI 和 EFCore 3。 如何处理通用存储库方法中的事务？我知道存储库模式的优缺点，以及它的通用存储库方法，但让我感到困惑的是如何在使用它们时处理事务？？

下面是我使用的BaseRepository。我在执行这样的事务时遇到问题：

1. 添加Employee
2. 创建EmployeeId
3. 将Employee 的地址添加到刚刚创建的EmployeeId

我遇到的问题是我必须调用SaveChanges 来获取自动生成的员工 ID，以便能够插入员工的地址。 SaveChanges 提交事务（由 EF Core 创建）。 在使用BaseRepository 时，如何在事务中执行此操作？我是否应该在 BaseRepository 中公开 BeginTransaction 和 Commit 方法，以便 Service 类可以创建事务并关闭它？

    public abstract class BaseRepository<TEntity> : IRepository<TEntity> 
        where TEntity : class, IEntity
    {
        private readonly DemoDb_context _context;

        public BaseRepository(DemoDb_context context)
        {
            _context = context;
        }

        public async Task<TEntity> GetById(int id)
        {
            return await _context.Set<TEntity>().FindAsync(id);
        }

        public async Task<List<TEntity>> GetAll()
        {
            return await _context.Set<TEntity>().ToListAsync();
        }

        public async Task<TEntity> Add(TEntity entity)
        {
            _context.Set<TEntity>().Add(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task<TEntity> Delete(int id)
        {
            var entity = await _context.Set<TEntity>().FindAsync(id);
            if (entity == null)
            {
                return entity;
            }

            _context.Set<TEntity>().Remove(entity);
            await _context.SaveChangesAsync();

            return entity;
        }

        public async Task<TEntity> Update(TEntity entity)
        {
            _context.Entry(entity).State = EntityState.Modified;
            await _context.SaveChangesAsync();
            return entity;
        }
    }

这是我的服务类，我认为应该在其中添加事务：

public class EmployeeService
{
    private readonly IEmployeeRepository _employeeRepository;
    private readonly IAddressRepository _addressRepository;
    private readonly IMapper _mapper;

    public EmployeeService(IEmployeeRepository employeeRepository, IAddressRepository addressRepository, IMapper mapper)
    {
        _employeeRepository = employeeRepository;
        _addressRepository = addressRepository;
        _mapper = mapper;
    }

    public async Task<EmployeeDto> Add(EmployeeDto employeeDto)
    {
        // TODO: Start transaction here ???

        var employee = _mapper.Map<Employee>(employeeDto);
        var addedEmployee = await _employeeRepository.Add(employee);

        var employeeAddress = Generate_Employee_Address_Entity_With_EmployeeId(addedEmployee); 
        var addedAddress = await _addressRepository.Add(employeeAddress);

        var output = Generate_Employee_Dto(addedEmployee, addedAddress); 

        // TODO: Commit transaction here ???

        return outputs;
    }
}

Answer 1

实体框架的优点之一是您可以避免在您向我们展示的那种基本案例场景中使用事务。我建议如下：

1. 在 BaseRepository 中，从 Add、Update 和 Delete 方法中删除 SaveChangesAsync，并公开一个名为 SaveDbChangesAsync() 的方法。

     public abstract class BaseRepository<TEntity> : IRepository<TEntity> 
           where TEntity : class, IEntity
       {
           private readonly DemoDb_context _context;
   
           public BaseRepository(DemoDb_context context)
           {
               _context = context;
           }
   
           public async Task<TEntity> GetById(int id)
           {
               return await _context.Set<TEntity>().FindAsync(id);
           }
   
           public async Task<List<TEntity>> GetAll()
           {
               return await _context.Set<TEntity>().ToListAsync();
           }
   
           public async Task<TEntity> Add(TEntity entity)
           {
               _context.Set<TEntity>().Add(entity);
               return entity;
           }
   
           public async Task<TEntity> Delete(int id)
           {
               var entity = await _context.Set<TEntity>().FindAsync(id);
               if (entity == null)
               {
                   return entity;
               }
   
               _context.Set<TEntity>().Remove(entity);    
               return entity;
           }
   
           public async Task<TEntity> Update(TEntity entity)
           {
               _context.Entry(entity).State = EntityState.Modified;
               return entity;
           }
   
           public async Task SaveDbChangesAsync()
           {
                await _context.SaveChangesAsync();
           }
       }
   

通过这种方式，您不会将更改存储到数据库中，而只会在上下文中的内存中跟踪更改。

1. 完成所有逻辑后，您可以从服务类（通常是使用存储库的类）中调用 SaveDbChangesAsync() 方法并保留更改。

   public class EmployeeService
   {
       private readonly IEmployeeRepository _employeeRepository;
       private readonly IAddressRepository _addressRepository;
       private readonly IMapper _mapper;
   
       public EmployeeService(IEmployeeRepository employeeRepository, IAddressRepository addressRepository, IMapper mapper)
       {
           _employeeRepository = employeeRepository;
           _addressRepository = addressRepository;
           _mapper = mapper;
       }
   
       public async Task<EmployeeDto> Add(EmployeeDto employeeDto)
       {
           // TODO: Start transaction here ???
   
           var employee = _mapper.Map<Employee>(employeeDto);
           var addedEmployee = await _employeeRepository.Add(employee);
   
           var employeeAddress = Generate_Employee_Address_Entity_With_EmployeeId(addedEmployee); 
           var addedAddress = await _addressRepository.Add(employeeAddress);
   
           var output = Generate_Employee_Dto(addedEmployee, addedAddress); 
   
   
           //// Here instead of commit transaction, we save changes to
           //// the database. If anything goes wrong changes will be discarded 
           //// anyways when you context gets out of scope;
           await SaveDbChangesAsync();
   
           return outputs;
       }
   

好处：

1. 避免使用事务等性能要求高的操作
2. 您以正确的方式使用 EF

但是，如果您坚持使用交易，您可以执行以下操作：

using (EntitiesContext context = new EntitiesContext())  
{  
    using (var transaction = context.Database.BeginTransaction())  
    {  
    }
}