工作单元(UnitOfWork) 模式 (2) .NET Core

2021-04-20 10:27

阅读:541

标签:err   use   res   运行   实例   on()   观察   nsa   控制   

1.工作单元(UnitOfWork)是什么?

  Maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.

  UnitOfWork是Martin Fowler提出的,上面是他说的话,这里要注意的就是分两个时间点,a)业务操作过程中,对操作的CUD操作的对象状态进行跟踪操作; b) CUD操作完毕提交到数据库,UnitOfWork保证业务提交使用同意上下文对象,从而保证了事务的一致性,假设提交失败直接回滚。

  简单说:UnitOfWork可以说是一个开关,开:用于上下文的获取,供所有的仓储对象使用;关:提交操作,提交的过程包含事务控制(是否回滚)。

  所以他这一句话我们可以明确这几个东西:

  1. 一个对象用于存放 业务操作的对象(我们结合仓储使用就是仓储了) repository的临时存储对象;
  2. 同一业务操作的上下文必须保持一致(同一上下文对象);
  3. 维护当前业务的变更操作;
  4. 事务控制;

  依据这几点,我们就可以写出想要的代码,(临时先刨除 第三点 ,后面会有补充),先声明:这里未考虑多上下文的情况,因为我这边用不到,但是实现也比较简单,可以将涉及到的hashtable对象换成dictionary等,键为上下位对象类型或者名称。

  接口定义:

/// 
///     工作单元接口
/// 
public interface IUnitOfWork : IDisposable
{
    IRepository Repository() where TEntity : class, IEntity;
    void BeginTransaction();
    int Commit();
    Task CommitAsync();
}
public class UnitOfWork : IUnitOfWork
{
    /// 
    ///     服务提供器,主要用于查找 框架配置对象,以及DbContextOptionBuilder对象
    /// 
    private readonly IServiceProvider _provider;
    /// 
    ///     当前请求涉及的scope生命的仓储对象
    /// 
    private Hashtable repositorys;

    private IDbContextTransaction _dbTransaction { get; set; }
    /// 
    ///     上下文对象,UnitOfWork内部初始化上下文对象,供当前scope内的操作使用,保证同一上下文
    /// 
    public DbContext DbContext => GetDbContext();

    public UnitOfWork(IServiceProvider provider)
    {
        _provider = provider;
    }

    public IRepository Repository() where TEntity : class, IEntity
    {
        if (repositorys == null)
            repositorys = new Hashtable();

        var entityType = typeof(TEntity);
        if (!repositorys.ContainsKey(entityType.Name))
        {
            var baseType = typeof(Repository);
            var repositoryInstance = Activator.CreateInstance(baseType.MakeGenericType(entityType), DbContext);
            repositorys.Add(entityType.Name, repositoryInstance);
        }

        return (IRepository)repositorys[entityType.Name];
    }

    public void BeginTransaction()
    {
        //DbContext.Database.UseTransaction(_dbTransaction);//如果多上下文,我们可是在其他上下文直接使用 UserTransaction使用已存在的事务
        _dbTransaction = DbContext.Database.BeginTransaction();
    }

    public int Commit()
    {
        int result = 0;
        try
        {
            result = DbContext.SaveChanges();
            if (_dbTransaction != null)
                _dbTransaction.Commit();
        }
        catch (Exception ex)
        {
            result = -1;
            CleanChanges(DbContext);
            _dbTransaction.Rollback();
            throw new Exception($"Commit 异常:{ex.InnerException}/r{ ex.Message}");
        }
        return result;
    }

    public async Task CommitAsync()
    {
        int result = 0;
        try
        {
            result = await DbContext.SaveChangesAsync();
            if (_dbTransaction != null)
                _dbTransaction.Commit();
        }
        catch (Exception ex)
        {
            result = -1;
            CleanChanges(DbContext);
            _dbTransaction.Rollback();
            throw new Exception($"Commit 异常:{ex.InnerException}/r{ ex.Message}");
        }
        return await Task.FromResult(result);
    }

    private DbContext GetDbContext()
    {
        var options = _provider.ESoftorOption();
        IDbContextOptionsBuilderCreator builderCreator = _provider.GetServices()
            .FirstOrDefault(d => d.DatabaseType == options.ESoftorDbOption.DatabaseType);

        if (builderCreator == null)
            throw new Exception($"无法解析数据库类型为:{options.ESoftorDbOption.DatabaseType}的{typeof(IDbContextOptionsBuilderCreator).Name}实例");
        //DbContextOptionsBuilder
        var optionsBuilder = builderCreator.Create(options.ESoftorDbOption.ConnectString, null);//null可以换成缓存中获取connection对象,以便性能的提升
        if (!(ActivatorUtilities.CreateInstance(_provider, options.ESoftorDbOption.DbContextType, optionsBuilder.Options) is DbContext))
            throw new Exception($"上下文对象'{options.ESoftorDbOption.DbContextType.AssemblyQualifiedName}'实例化失败,请确认配置文件已正确配置");
        return dbContext;
    }

    /// 
    ///     操作失败,还原跟踪状态
    /// 
    /// 
    private static void CleanChanges(DbContext context)
    {
        var entries = context.ChangeTracker.Entries().ToArray();
        for (int i = 0; i 

2.怎么用?

  就目前而言,博客园中可见到的大部分的 实现都是将 UnitOfWork 注入到 repository,通过 UnitOfWork 获取上下文对象,然后在 service 中只是直接注入所需的 repository 对象,是的,这的确满足我们的开发需求了,也能正常运行。

public class TestService
{
      private readonly ITestRepository _testRepository;
      public TestService(ITestRepository testRepository){
          _testRepository = testRepository;
      }  
      //......其他方法实现
}    

  如果有多个仓储对象,依次如上面的方式注入即可。但是,这样做的话,当以后我们有表删除或者新增的时候,我们不得不维护这样的列表。这完全不符合OO设计原则;如果我们有新表的创建或者删除,改动就比较多了。

  如果你有细细观察的话,我们这里的 UnitOfWork实现稍有不同,也就涉及到当前请求的 仓储对象(repository),我们在这临时存储到了一个 hashable对象中,那么这时候我们在 service中使用UnitOfWork和仓储的时候,就不用像上面那样,有多少个需要注册多少次,而只需要注入一个UnitOfWork对象即可。然后通过UnitOfWork获取 仓储对象(repository),因为我们临时将涉及到当前请求(事务)的 仓储已经存储到私有变量的 hashtable中。

public class TestService
{
      private readonly IUnitOfWork _UnitOfWork;
      public TestService(IUnitOfWork UnitOfWork){
      _UnitOfWork = UnitOfWork;
      }  
      //......其他方法实现
} 

  然后我们在使用仓储(repository)的时候,只需要如下方式使用即可:

  var userRepository = _UnitOfWork.Repository();
  var roleRepository = _UnitOfWork.Repository();
  ...

  而在我们用到事务的地方,直接使用UnitOfWork中的commit提交即可:

  _UnitOfWork.BeginTransaction();
  var userRepository = _UnitOfWork.Repository();
  var roleRepository = _UnitOfWork.Repository();
  ...//一些列其他操作,(CRUD)
  _UnitOfWork.Commit();

  就像上面说到的,这样保证了当前业务操作涉及的 仓储对象(repository),会保证在 hashtable对象中,同时使用同一个上下文对象(DbContext),Commit提交的时候保证了事务(上下文)的一致性。而且如上面提到的,我们只需要在service层中注入一个UnitOfWork即可,不论表如何变动,删除或者新增表,我们这里不会受到任何影响。比较理想的一种方式。

3.注意点?

  UnitOfWork模式注意点:
  1.由UnitOfWork初始化上下文对象,也就是我们代码中的DbContext
  2.由UnitOfWork提供事务的控制方法,以及控制事务回滚,保证最终一致性
  3.这里我们还使用了UnitOfWork进行仓储对象的获取。
  4.其他

4.补充:对象操作状态的控制

  上面有说到,UnitOfWork还需要对操作状态的控制,简单说就是,一系列的 增、删、改 命令操作的状态控制,可参考:https://www.cnblogs.com/zhaoshujie/p/12260188.html
  基本原理就是类似我们定义的 hashtable对象,定义三个 Dictionary 变量,用于存储当前业务操作涉及的 增、删、改 三种操作的存储变量。

工作单元(UnitOfWork) 模式 (2) .NET Core

标签:err   use   res   运行   实例   on()   观察   nsa   控制   

原文地址:https://www.cnblogs.com/zhaoshujie/p/12260363.html


评论


亲,登录后才可以留言!