How to decouple my repositories and unitofwork in order to make them testable

Question

actually I have implemented my repositories and unitofwork this way and I also found an informative answer by Mr.qujck regarding my question which helped me to a large extent but the only problem I have is that in that topic according to his answer I have no idea how and where should I implement my CRUD operations.I also have this question which has remained unanswered .I would be grateful if someone can help me.

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...
    }