namespace UnitOfWork
{
    public interface IAggregateRoot : IAggregateRoot,IEntity
    {
}

public interface IAggregateRoot<TPrimaryKey> : IEntity<TPrimaryKey>
{

}
}

namespace UnitOfWork
{
    public interface IRepository : IRepository
        where TEntity : class,IEntity,IAggregateRoot
    {
}

public interface IRepository<TEntity,TPrimaryKey>
    where TEntity : class,IEntity<TPrimaryKey>,IAggregateRoot<TPrimaryKey>
{        
    IQueryable<TEntity> GetAll();

    TEntity Get(TPrimaryKey id);

    TEntity FirstOrDefault(TPrimaryKey id);

    TEntity Insert(TEntity entity);

    TEntity Update(TEntity entity);

    void Delete(TEntity entity);

    void Delete(TPrimaryKey id);
}
}

因为仓储是管理聚合的，所以我们需要限制泛型参数为实现IAggregateRoot的类。

amespace UnitOfWork.Repositories
{
    public class EfCoreRepository
        : EfCoreRepository,IRepository
        where TEntity : class,IAggregateRoot
    {
        public EfCoreRepository(UnitOfWorkDbContext dbDbContext) : base(dbDbContext)
        {
        }
    }
public class EfCoreRepository<TEntity,TPrimaryKey>
    : IRepository<TEntity,IAggregateRoot<TPrimaryKey>
{
    private readonly UnitOfWorkDbContext _dbContext;

    public virtual DbSet<TEntity> Table => _dbContext.Set<TEntity>();

    public EfCoreRepository(UnitOfWorkDbContext dbDbContext)
    {
        _dbContext = dbDbContext;
    }

    public IQueryable<TEntity> GetAll()
    {
        return Table.AsQueryable();
    }

    public TEntity Insert(TEntity entity)
    {
        var newEntity = Table.Add(entity).Entity;
        _dbContext.SaveChanges();
        return newEntity;
    }

    public TEntity Update(TEntity entity)
    {
        AttachIfNot(entity);
        _dbContext.Entry(entity).State = EntityState.Modified;

        _dbContext.SaveChanges();

        return entity;
    }

    public void Delete(TEntity entity)
    {
        AttachIfNot(entity);
        Table.Remove(entity);

       _dbContext.SaveChanges();
    }

    public void Delete(TPrimaryKey id)
    {
        var entity = GetFromChangeTrackerOrNull(id);
        if (entity != null)
        {
            Delete(entity);
            return;
        }

        entity = FirstOrDefault(id);
        if (entity != null)
        {
            Delete(entity);
            return;
        }
    }

    protected virtual void AttachIfNot(TEntity entity)
    {
        var entry = _dbContext.ChangeTracker.Entries().FirstOrDefault(ent => ent.Entity == entity);
        if (entry != null)
        {
            return;
        }

        Table.Attach(entity);
    }

    private TEntity GetFromChangeTrackerOrNull(TPrimaryKey id)
    {
        var entry = _dbContext.ChangeTracker.Entries()
            .FirstOrDefault(
                ent =>
                    ent.Entity is TEntity &amp;&amp;
                    EqualityComparer<TPrimaryKey>.Default.Equals(id,((TEntity)ent.Entity).Id)
            );

        return entry?.Entity as TEntity;
    }
}
}

因为我们直接使用EF Core进行持久化，所以我们直接通过构造函数初始化DbContex实例。同时，我们注意到Insert、Update、Delete方法都显式的调用了SaveChanges方法。

至此，我们完成了从实体到聚合再到仓储的定义和实现，万事俱备，只欠Uow。

通过第3节的说明我们已经知道，EF Core已经实现了UOW模式。而为了确保领域层透明的进行持久化，我们对其进行了更高一层的抽象，实现了仓储模式。但这似乎引入了另外一个问题，因为仓储是管理单一聚合的，每次做增删改时都显式的提交了更改（调用了SaveChanges），在处理多个聚合时，就无法利用DbContext进行批量提交了。那该如何是好？一不做二不休，我们再对其进行一层抽象，抽离保存接口，这也就是Uow的核心接口方法。 我们抽离SaveChanges方法，定义IUnitOfWork接口。

namespace UnitOfWork
{
    public interface IUnitOfWork
    {
        int SaveChanges();
    }
}

因为我们是基于EFCore实现Uow的，所以我们只需要依赖DbContex，就可以实现批量提交。实现也很简单：

namespace UnitOfWork
{
    public class UnitOfWork : IUnitOfWork where TDbContext : DbContext
    {
        private readonly TDbContext _dbContext;
    public UnitOfWork(TDbContext context)
    {
        _dbContext = context ?? throw new ArgumentNullException(nameof(context));
    }

    public int SaveChanges()
    {
        return _dbContext.SaveChanges();
    }
}
}

既然Uow接手保存操作，自然我们需要：注释掉EfCoreRepository中Insert、Update、Delete方法中的显式保存调用_dbContext.SaveChanges();。

那如何确保操作多个仓储时，最终能够一次性提交所有呢？

确保Uow和仓储共用同一个DbContex即可。这个时候我们就可以借助依赖注入。

我们直接使用.net core 提供的依赖注入，依次注入DbContext、UnitOfWork和Repository。

//注入DbContext
services.AddDbContext(
    options =>options.UseSqlServer(
    Configuration.GetConnectionString("DefaultConnection")));
//注入Uow依赖

services.AddScoped<IUnitOfWork,UnitOfWork>();
//注入泛型仓储

services.AddTransient(typeof(IRepository<>),typeof(EfCoreRepository<>));

services.AddTransient(typeof(IRepository<,>),typeof(EfCoreRepository<,>));

这里我们限定了DbContext和UnitOfWork的生命周期为Scoped，从而确保每次请求共用同一个对象。如何理解呢？就是整个调用链上的需要注入的同类型对象，使用是同一个类型实例。

下面我们就来实际看一看如何使用UOW，我们定义一个应用服务：

namespace UnitOfWork.Customer
{
    public class CustomerAppService : ICustomerAppService
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly IRepository _customerRepository;
        private readonly IRepository _shoppingCartRepository;
    public CustomerAppService(IRepository<ShoppingCart> shoppingCartRepository,IRepository<Customer> customerRepository,IUnitOfWork unitOfWork)
    {
        _shoppingCartRepository = shoppingCartRepository;
        _customerRepository = customerRepository;
        _unitOfWork = unitOfWork;
    }

    public void CreateCustomer(Customer customer)
    {
        _customerRepository.Insert(customer);//创建客户

        var cart = new ShoppingCart.ShoppingCart() {CustomerId = customer.Id};
        _shoppingCartRepository.Insert(cart);//创建购物车
        _unitOfWork.SaveChanges();
    }

    //....
}
}

通过以上案例，我们可以看出，我们只需要通过构造函数依赖注入需要的仓储和Uow即可完成对多个仓储的持久化操作。

对于Uow模式，有很多种实现方式，大多过于复杂抽象。EF和EF Core本身已经实现了Uow模式，所以在实现时，我们应避免不必要的抽象来降低系统的复杂度。

最后，重申一下：Uow模式是用来管理仓储处理事务的，仓储用来解耦的（领域层与基础设施层）。而基于EF实现Uow模式的关键：确保Uow和Reopository之间共享同一个DbContext实例。

最后附上使用.Net Core和EF Core基于DDD分层思想实现的源码：?

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!