Question

说我有以下实现：

//Generic repository.
public interface IRepository<T> where T : class {
   void Insert(T entity);
   void Delete(int id);
   void SaveChanges();
   //..more generic functions
}

//Repository implementation.
public class EFRepository<T> : IRepository<T> where T: class {
   private MyDbContext context;
   protected DbSet<T> dbSet;

   public EFRepository(): this(new MyDbContext()){}

   public EFRepository(MyDbContext context)
   {
      this.context = context;
      dbSet = context.Set<T>();
   }

   public void Insert(T entity)
   {
      dbSet.Add(entity);
   }

   public void Delete(int id)
   {
      dbSet.Remove(dbSet.Find(id));
   }

   public void SaveChanges()
   {
      context.SaveChanges();
   }
   //...more generic implementations
}

//Unit of Work Interface
public interface IUnitOfWork: IDisposable
{
   IRepository<EntityA> ARepository { get; }
   IRepository<EntityB> BRepository { get; }
   //...more stuff
}

//Unit of Work Implementation
public class EFUnitOfWork: IUnitOfWork
{
   private MyDbContext context = new MyDbContext();

   private IRepository<EntityA> aRepository;
   private IRepository<EntityB> bRepository;

   public IRepository<EntityA> ARepository 
   {
      get
      {
            if (this.aRepository == null)
               this.aRepository = new EFRepository<EntityA>(context);

            return this.aRepository;
      }

   }

   public IRepository<EntityB> BRepository 
   {
      get
      {
            if (this.bRepository == null)
               this.bRepository = new EFRepository<EntityB>(context);

            return this.bRepository;
      }

   }

   //...more stuff
}

最后，我的解析器中有以下绑定：

kernel.Bind(typeof(IRepository<>)).To(typeof(EFRepository<>));
kernel.Bind(typeof(IUnitOfWork)).To(typeof(EFUnitOfWork));

现在，我的问题是......我将如何扩展EntityA的存储库，使其拥有的操作多于通用存储库？

到目前为止我会发布一些内容......

编辑：这是我到目前为止所拥有的：

//New interface.
public class IEntityARepository : IRepository<EntityA>
{
   void DoSomethingSpecificToEntityA();
}

//New implementation.
public class EFEntityARepository : EFRepository<EntityA>
{
   public EFEntityARepository(MyDbContext context) : base(context) {}
   //add additional methods for EntityA
   public void DoSomethingSpecificToEntityA()
   {

   }

}


//Modify Unit of Work Interface as follows.
//Unit of Work Interface
public interface IUnitOfWork: IDisposable
{
   IEntityARepository  ARepository { get; }
   IRepository<EntityB> BRepository { get; }
   //...more stuff
}

//Modify Unit of Work Implementation as follows.
public class EFUnitOfWork: IUnitOfWork
{
   private MyDbContext context = new MyDbContext();

   private IEntityARepository  aRepository;
   private IRepository<EntityB> bRepository;

   public IEntityARepository   ARepository 
   {
      get
      {
            if (this.aRepository == null)
               this.aRepository = new EFEntityARepository<EntityA>(context);

            return this.aRepository;
      }

   }

   public IRepository<EntityB> BRepository 
   {
      get
      {
            if (this.bRepository == null)
               this.bRepository = new EFRepository<EntityB>(context);

            return this.bRepository;
      }

   }

   //...more stuff
}

添加以下绑定：

kernel.Bind(typeof(IEntityARepository)).To(typeof(EFEntityARepository));

但是，我确定这不正确。或者至少，不是正确的方法。

Answer 1

如果我理解正确的话，你可以从你的通用类的特定类型版本中拯救出来......

public class EFEntityARepository : EFRepository<EntityA>, IEntityARepository 
{
    //Add more opps
}

我认为工作单元需要看起来像这样：

   public IEntityARepository   ARepository 
   {
      get
      {
            if (this.aRepository == null)
               this.aRepository = new EFEntityARepository(context);

            return this.aRepository;
      }

   }

Answer 2

好的，所以我通过添加和/或修改原始代码来实现它，如下所示：

//New interface for the extension of the repository.
//Is it possible to do this without defining this new interface? Doesn't seem like it.
public class IEntityARepository : IRepository<EntityA>
{
   void DoSomethingSpecificToEntityA();
}

//Add new class.
//It looks like you have to inherit from IEntityARepository as well.
public class EFEntityARepository : EFRepository<EntityA>, IEntityARepository
{

   public EFEntityARepository(MyDbContext context) : base(context) {}

   //add additional methods for EntityA
   public void DoSomethingSpecificToEntityA()
   {

   }

}


//Modify Unit of Work Interface as follows.
public interface IUnitOfWork: IDisposable
{
   IEntityARepository ARepository { get; }
   IRepository<EntityB> BRepository { get; }
   //...more stuff
}

//Modify Unit of Work Implementation as follows.
public class EFUnitOfWork: IUnitOfWork
{
   private MyDbContext context = new MyDbContext();

   private IEntityARepository aRepository;
   private IRepository<EntityB> bRepository;

   public IEntityARepository ARepository 
   {
      get
      {
            if (this.aRepository == null)
               this.aRepository = new EFEntityARepository(context);

            return this.aRepository;
      }

   }

   public IRepository<EntityB> BRepository 
   {
      get
      {
            if (this.bRepository == null)
               this.bRepository = new EFRepository<EntityB>(context);

            return this.bRepository;
      }

   }

   //...more stuff
}

它有效......但这是最好的方法吗？

MVC通用存储库/工作单元模式 - 扩展存储库

2 个答案: