如果我有一个Service类和IRepository，我需要一个存储库类吗？

Question

看完后，this question。我想我需要查看我的结构以避免多余的代码。

我目前的结构是Controller - > Repository - > IRepository。

信息库看起来是这样的：

public class UserRepository : IUserRepository, IDisposable 
{ 
    private StudentSchedulingEntities _context; 

    public UserRepository(StudentSchedulingEntities context) 
    { 
     if (context == null) 
      throw new ArgumentNullException("context"); 

     _context = context; 
    } 
    public IEnumerable<User> GetUsers() 
    { 
     return _context.Users.ToList(); 
    } 
    public User GetUserByID(int id) 
    { 
     return _context.Users.Find(id); 

    } 
    public void InsertStudent(User user) 
    { 
     _context.Users.Add(user); 
    } 
    public void DeleteStudent(int userID) 
    { 
     User usr = _context.Users.Find(userID); 
     _context.Users.Remove(usr); 
    } 
    public void UpdateStudent(User user) 
    { 
     _context.Entry(user).State = EntityState.Modified; 
    } 
    public void Save() { 
     _context.SaveChanges(); 
    } 
    public void Dispose() 
    { 
     Dispose(true); 
     GC.SuppressFinalize(this); 
    } 
    protected virtual void Dispose(bool disposing) 
    { 
     if (disposing) 
     { 
      if (_context != null) 
      { 
       _context.Dispose(); 
       _context = null; 
      } 
     } 
    } 
} 

我IRepository看起来是这样的：

public interface IUserRepository : IDisposable 
{ 
    IEnumerable<User> GetUsers(); 
    User GetUserByID(int userID); 
    void InsertStudent(User user); 
    void DeleteStudent(int userID); 
    void UpdateStudent(User user); 
    void Save(); 
} 

我想避免再次在服务层这样做。我是否需要存储库类或者是否应该实施服务层来替换存储库？

Answer 1

您的服务层将不再需要任何资料库的实现，它只会使用存储库来查找用户，添加/编辑/删除用户，等等。现在

，如果我可以提供一点意见，我建议去一个通用的存储库。这样，如果您需要制作新的存储库，它非常简单。我们使用nopCommerce，和他们使用下面的代码：

public partial interface IRepository<T> where T : BaseEntity 
{ 
    T GetById(object id); 
    void Insert(T entity); 
    void Update(T entity); 
    void Delete(T entity); 
    IQueryable<T> Table { get; } 
} 

而且由于它使用实体框架，这是实现：

/// <summary> 
/// Entity Framework repository 
/// </summary> 
public partial class EfRepository<T> : IRepository<T> where T : BaseEntity 
{ 
    private readonly IDbContext _context; 
    private IDbSet<T> _entities; 

    /// <summary> 
    /// Ctor 
    /// </summary> 
    /// <param name="context">Object context</param> 
    public EfRepository(IDbContext context) 
    { 
     this._context = context; 
    } 

    public T GetById(object id) 
    { 
     return this.Entities.Find(id); 
    } 

    public void Insert(T entity) 
    { 
     try 
     { 
      if (entity == null) 
       throw new ArgumentNullException("entity"); 

      this.Entities.Add(entity); 

      this._context.SaveChanges(); 
     } 
     catch (DbEntityValidationException dbEx) 
     { 
      var msg = string.Empty; 

      foreach (var validationErrors in dbEx.EntityValidationErrors) 
       foreach (var validationError in validationErrors.ValidationErrors) 
        msg += string.Format("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage) + Environment.NewLine; 

      var fail = new Exception(msg, dbEx); 
      //Debug.WriteLine(fail.Message, fail); 
      throw fail; 
     } 
    } 

    public void Update(T entity) 
    { 
     try 
     { 
      if (entity == null) 
       throw new ArgumentNullException("entity"); 

      this._context.SaveChanges(); 
     } 
     catch (DbEntityValidationException dbEx) 
     { 
      var msg = string.Empty; 

      foreach (var validationErrors in dbEx.EntityValidationErrors) 
       foreach (var validationError in validationErrors.ValidationErrors) 
        msg += Environment.NewLine + string.Format("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage); 

      var fail = new Exception(msg, dbEx); 
      //Debug.WriteLine(fail.Message, fail); 
      throw fail; 
     } 
    } 

    public void Delete(T entity) 
    { 
     try 
     { 
      if (entity == null) 
       throw new ArgumentNullException("entity"); 

      this.Entities.Remove(entity); 

      this._context.SaveChanges(); 
     } 
     catch (DbEntityValidationException dbEx) 
     { 
      var msg = string.Empty; 

      foreach (var validationErrors in dbEx.EntityValidationErrors) 
       foreach (var validationError in validationErrors.ValidationErrors) 
        msg += Environment.NewLine + string.Format("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage); 

      var fail = new Exception(msg, dbEx); 
      //Debug.WriteLine(fail.Message, fail); 
      throw fail; 
     } 
    } 

    public virtual IQueryable<T> Table 
    { 
     get 
     { 
      return this.Entities; 
     } 
    } 

    private IDbSet<T> Entities 
    { 
     get 
     { 
      if (_entities == null) 
       _entities = _context.Set<T>(); 
      return _entities; 
     } 
    } 
     //TODO implement IDisposable interface 
} 

现在，它会像IRepository<User>或IRepository<Whatever>一样简单。

Answer 2

绝对没有冗余代码:-)当你说：

我现在的结构是控制器 - >库 - >

在控制器从库继承？你也不想要那样。存储库层通常连接到存储（XML，数据库，文件系统等）并映射到存储库友好的类。另一层管理存储库层到本地业务/服务类的映射。