这是一个很好的 UnitOfWork 与 DDD 周围的存储库模式设计吗

Question

我正在使用 UOW 和存储库模式构建一个 Web 应用程序。我对此有基本的了解，我想知道是否应该为项目中的所有表保留一个 UOW 实现，或者根据功能保留一个单独的实现，例如：

public interface IHomeUOW
{
    IGenericRepository<User> Users { get; }
    IGenericRepository<TableA> Table_A { get; }
    IGenericRepository<TableB> Table_B{ get; }
}

public interface IBusinessCaseUOW
{

    IGenericRepository<TableA> Table_A { get; }
    IGenericRepository<TableXYZ> Table_XYZ{ get; }
}

如您所见，TableA 在 Home UOW 和特定业务案例 UOW 中都可用。一个 UOW 部分实现如下：

public class UnitOfWork : IUnitOfWork
{

    private readonly ObjectContext _context;
    private UserRepository _userRepository;


    public UnitOfWork(ObjectContext Context)
    {

        if (Context == null)
        {
            throw new ArgumentNullException("Context wasn't supplied");
        }
        _context = Context;
    }

    public IGenericRepository<User> Users
    {
        get
        {
            if (_userRepository == null)
            {
                _userRepository = new UserRepository(_context);
            }

            return _userRepository;
        }
    }
 }

我的仓库会是这样的

    public interface IGenericRepository<T>
    where T : class
    {
        //Fetch records
        T GetSingleByRowIdentifier(int id);             
        T GetSingleByRowIdentifier(string id);          

        IQueryable<T> FindByFilter(Expression<Func<T, bool>> filter);  

        // CRUD Ops
        void AddRow(T entity);
        void UpdateRow(T entity);
        void DeleteRow(T entity);

    }


    public abstract class GenericRepository<T> : IGenericRepository<T>
            where T : class
    {
        protected IObjectSet<T> _objectSet;
        protected ObjectContext _context;

        public GenericRepository(ObjectContext Context)
        {
            _objectSet = Context.CreateObjectSet<T>();
            _context = Context;
        }

        //Fetch Data
        public abstract T GetSingleByRowIdentifier(int id);
        public abstract T GetSingleByRowIdentifier(string id);


        public IQueryable<T> FindByFilter(Expression<Func<T, bool>> filter)
        {
            //
        }

        //CRUD Operations implemented

    }

   public class UserRepository : GenericRepository<User>
   {
         public UserRepository(ObjectContext Context)
         : base(Context)
         {
         }

         public override User GetSingleByRowIdentifier(int id)
         {
          //implementation
         }

         public override User GetSingleByRowIdentifier(string username)
         {
          //implementation
         }
   }

你怎么看？如果这不是 DDD 的 UOW 和 Repository 模式的正确实现，它会因为只是编写一堆代码来抽象对 EF 表的调用而失败吗？

感谢您的宝贵时间..

Answer 1

我对通用存储库过敏。每次我使用一个时，我都必须做一些破坏打开/关闭原则的变通方法。

我建议您切换到根聚合特定存储库并在其中使用您的 OR/M。

关于工作单元。 EF 和 nhibernate 已经实现了该模式。只需创建一个类似的接口：

public interface IUnitOfWork : IDisposable
{
    void SaveChanges();
}

处置而不保存 = 回滚。

一个 nhibernate 实现看起来像（快速编写，未经测试）：

public class NHibernateUnitOfWork : IDisposable
{
    public NHibernateUnitOfWork(ISession session)
    {
        _transaction = session.BeginTransaction();
    }

    public void SaveChanges()
    {
        _transaction.Commit();
    }

    public void Dispose()
    { 
        _transaction.Dispose();
    }
}

使用 IoC 容器非常容易。只需在其中注册实现即可。

我最喜欢在 ASP.NET MVC 中获得事务支持的解决方案是创建一个自定义的 ActionFilter，命名为 TransactionalAttribute，并让它处理 UnitOfWork 实现：

[HttpPost, Transactional]
public ActionResult Update(YourModel model)
{
}

我刚刚将答案转换成更详细的博文：http://blog.gauffin.org/2012/02/repositories-unit-of-work-and-asp-net-mvc/

Answer 2

我认为这是错误的。

UnitOfWork 是事务（简单来说）。它至少应该包含一个方法 Complete(Commit)。

如果使用 EntityFramework，则包装 ObjectContext，如果使用纯 ADO .NET，则包装 TransactionScope，如果使用 NHibernate ISession，等等。

这是我的 UOF：

public interface IUnitOfWork : IDisposable
{
    void Complete();
    TRepository GetRepository<TRepository, TItem>()
        where TRepository : IRepository<TItem>
        where TItem : class;
}