如何使我的存储库和工作单元脱钩以使其可测试

Question

实际上，我已经以这种方式实现了我的存储库和工作单元，并且我还发现了Qujck先生关于我的问题的翔实的回答 ，这在很大程度上帮助了我，但是我唯一的问题是，根据他的回答，该主题中我不知道我应该如何以及在哪里实施CRUD操作。我也有这个问题尚未得到解答。如果有人可以帮助我，我将不胜感激。

Answer 1

EntityFramework already provides you with all the functionality regarding CRUD operations, and generally speaking, you don't need to test EntityFramework, because we just assume that it works. The way it is shown in that website, is that you create a higher abstraction layer than simple CRUD operations, build it on top of EF, and call it Repository (Data access layer). So in this case, you only need to make sure that you DAL (aka Repository in this case) is decoupled. The only thing repository is coupled to is EntityFramework's DbContext, which, is not realy decouplable from, so the lowest level of abstraction that you realy need to test and decouple upwards is your Repository class.

Answer 2

The way the Unit Of Work pattern is being employed in that example does not truly represent how a UoW should behave. The repositories should have knowledge of the UoW, but the UoW should not have any reference to your repositories. The UoW should only know about your context. In my example below, you remove the repository dependencies from the UoW. For testing, you could implement a fake DbContext if you really needed to, bu that may be overkill.

Another suggestion I have is to add one further abstraction to your repositories and create a Service layer. This will act as your Business layer and these would be injected into your MVC controllers. This way, if you work with DTOs or view models, you can map betwen entities and DTO in that layer so the application will never really expose your underlying DAL.

    public interface IUnitOfWork : IDisposable
    {
        /// <summary>
        /// Flushes content of unit of work to the underlying data storage. 
        /// Causes unsaved entities to be written to the data storage.
        /// </summary>
        void Flush();

        /// <summary>
        /// Begins the transaction.
        /// </summary>
        ITransaction BeginTransaction();

        /// <summary>
        /// Ends transaction.
        /// Note: suggested pattern to manage a transaction is via *using* construct.
        /// You should set input param to null after calling the method.
        /// </summary>
        /// <example>
        /// using ( var tnx = uow.BeginTransaction() ) { /* do some work */ }
        /// </example>
        /// See also <seealso cref="ITransaction"/> interface for more details.
        void EndTransaction(ITransaction transaction);

        /// <summary>
        /// Inserts entity to the storage.
        /// </summary>
        void Create<TEntity>(TEntity entity) where TEntity : class;

        /// <summary>
        /// Updates entity in the storage.
        /// </summary>
        void Update<TEntity>(TEntity entity) where TEntity : class;

        /// <summary>
        /// Updates entity in the storage.
        /// </summary>
        void Merge<TEntity>(TEntity original, TEntity current) where TEntity : class;


        /// <summary>
        /// Deletes entity in the storage.
        /// </summary>
        void Delete<TEntity>(TEntity entity) where TEntity : class;


    }

    public interface IRepository<TEntity> where TEntity: class
    {
        void Create(TEntity entity);
        TEntity GetById(object id);
        IEnumerable<TEntity> Get(Expression<Func<TEntity, bool>> criteria);
          IEnumerable<TEntity> GetAll();
        void Delete(object id);
        void Delete(TEntity entity);
        void Update(TEntity entity);
        void Merge(TEntity original, TEntity current);
        IUnitOfwork UnitOfWork { get; }
    }




    public class EntityFrameworkUnitOfWork: DbContext, IUnitOfwork
    {
        public virtual void Flush()
        {
            //The DbContext Save Changes method..
            SaveChanges();
        }    

        public virtual void Create<TEntity>(TEntity entity) where TEntity : class
        {
            base.Set<TEntity>().Add(entity);
        }

       ..other method implementations...
     }


 public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
    {
        private readonly IUnitOfWork _unitOfWork;

        public Repository(IUnitOfWork unitOfWork)
        {
            _unitOfWork = unitOfWork;
        }

        ...other method implementations...
    }