I’m new to this Repository pattern and have seen lot of repository pattern + UoW implementations all over the internet and I’m not able to reach to a conclusion as to which of them is correct . After going through many links I’ve been able to implement one .

Considering the following points in mind

• It should satisfy SOLID principles
• Be testable
• Be independent of framework
• Be independent of DB

Here is the code of the implementation

Generic IRepository

 public interface IRepository<T> where T : class     {          void Add(T entity);          void Update(T entity);          void Delete(T entity);          T GetByKey(object id);      } 

RepositoryBase

public abstract class RepositoryBase<D, T> : IRepository<T> where T : class where D : BaseDbContext {       private D dataContext;     private readonly IDbSet<T> dbSet;      protected IDbFactory<D> DbFactory     {         get;         private set;     }      protected D DbContext     {         get { return dataContext ?? (dataContext = DbFactory.Init()); }     }       protected RepositoryBase(IDbFactory<D> dbFactory)     {          DbFactory = dbFactory;         dbSet = DbContext.Set<T>();      }       #region Implementation     public virtual void Add(T entity)     {         dbSet.Add(entity);     }      public virtual void Update(T entity)     {         dbSet.Attach(entity);         DbContext.Entry(entity).State = EntityState.Modified;     }      public virtual void Delete(T entity)     {         dbSet.Remove(entity);     }       public T GetByKey(object id)     {         return dbSet.Find(id);     }       #endregion  } 

IUnitofWork , UnitOfWork

public interface IUnitOfWork<D> where D : BaseDbContext     {         void Commit();     }    public class UnitOfWork<D> : IUnitOfWork<D> where D : BaseDbContext, new() {     private readonly IDbFactory<D> dbFactory;     private D dbContext;      public UnitOfWork(IDbFactory<D> dbFactory)     {         this.dbFactory = dbFactory;     }      public D DbContext     {         get { return dbContext ?? (dbContext = dbFactory.Init()); }     }      public void Commit()     {         DbContext.SaveChanges();     } } 

IDBFactory ,DBFactory

public interface IDbFactory<D> where D : BaseDbContext {     D Init(); }     public class DbFactory<D> : Disposable, IDbFactory<D> where D : BaseDbContext, new()         {             D dbContext;             public D Init()             {                 return dbContext ?? (dbContext = new D());             }             protected override void DisposeCore()             {                 if (dbContext != null)                     dbContext.Dispose();             }         } 

BaseDbContext

public abstract class BaseDbContext : DbContext { public BaseDbContext(string nameOrConnectionString) : base(nameOrConnectionString)         {          }  } 

ProjectDbContext

 public partial class ProjectDbContext : BaseDbContext     {         public ProjectDbContext()             : base("name=ProjectDbContext")         {             Database.SetInitializer<ProjectDbContext>(null);         }       } 

EXAMPLE USAGE

Controller

 public class StudentsController : BaseController     {          private IStudentBusiness objstudentbusiness;         public StudentsController(IStudentBusiness rstudentbusiness)         {             objstudentbusiness = rstudentbusiness;         }           public JsonResult LoadStudents()         {                  var data = objstudentbusiness.ListStudents();                 var jsonResult = Json(data, JsonRequestBehavior.AllowGet);                 return jsonResult;          }      } 

IStudentBAL,StudentBAL

 public interface IStudentBAL     {         void SaveStudent(StudentDto student);         List<StudentDto> ListStudents();     }   public class StudentBAL : BusinessBase, IStudentBAL {      private readonly IStudentRepository objStudentRepository;     private readonly IUnitOfWork<ProjectDbContext> objIUnitOfWork;      public StudentBAL(IStudentRepository rIStudentRepository, IUnitOfWork<ProjectDbContext> rIUnitOfWork)     {         try         {             objStudentRepository = rIStudentRepository;             objIUnitOfWork = rIUnitOfWork;         }         catch (Exception ex)         {              Log.Error(ex);         }      }      public List<StudentDto> ListStudents()     {         try         {             var tusrs = objStudentRepository.ListStudents() ?? new List<StudentDto>();             return tusrs;         }         catch (Exception ex)         {             Log.Error(ex);          }         return new List<StudentDto>();     } } 

IStudentRepository,StudentRepository

 public interface IStudentRepository     {         void SaveStudent(Student Student);         StudentDto GetStudentByName(StudentDto Studentname);         Student GetStudentByID(int Studentid);         List<StudentDto> ListStudents();     }  public class StudentRepository : RepositoryBase<ProjectDbContext, Student>, IStudentRepository {     public StudentRepository(IDbFactory<ProjectDbContext> dbFactory) : base(dbFactory)     {     }     public List<StudentDto> ListStudents()     {              var students = (from t in DbContext.Students                          select new StudentDto                         {                            // all the required properties                         }).ToList();               return students;      } } 

• Dependency Injection is done using AutoFac
• Code for logging is omitted

I am asking if this seems like a good implementation or am I missing anything?

I would appreciate any feedback on my implementation you can offer regarding correctness, efficiency, and any suggestions. So here are my questions

• Is this loosely coupled ?
• Is it having any leaky abstraction and why ?
• What needs to be done to switch from EF to MySQL db and how much effort would it require to implement the changes?
• Is this pattern breaking any of the SOLID princples ,Law or Demeter or any Object Oriented laws?
• Does this pattern have any code redundancies which are not required ?
• How this architecture using EF would scale with a project containing more than 100+ domain entities and with each entity having at least more than 10 fields . Is it going to be maintenance nightmare later on?

-All criticisms greatly appreciated !!