首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >通用存储库和通用服务

问通用存储库和通用服务
EN

Code Review用户
提问于 2017-07-25 21:50:12
回答 1查看 7.4K关注 0票数 5

我在我的项目中使用了仓库/服务设计模式。我怀疑是否值得使用公共服务。

BaseEntity:

代码语言:javascript
复制
 public class BaseEntity
    {
        private DateTime _addedDate;
        private DateTime _modifiedDate;
        protected BaseEntity()
        {
            Id = Guid.NewGuid();
            AddedDate = DateTime.UtcNow;
        }

        [Key]
        public Guid Id { get; set; }
        public DateTime AddedDate
        {
            get => DateTime.SpecifyKind(_addedDate, DateTimeKind.Utc);
            private set => _addedDate = value;
        }
        public DateTime ModifiedDate
        {
            get => DateTime.SpecifyKind(_modifiedDate, DateTimeKind.Utc);
            set => _modifiedDate = value;
        }
    }

IGenericRepository:

代码语言:javascript
复制
   public interface IGenericRepository<T> where T : class
    {
        Task<T> FirstAsync(Expression<Func<T, bool>> predicate);
        Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate);

        /// <summary>
        /// Get all queries
        /// </summary>
        /// <returns>IQueryable queries</returns>
        IQueryable<T> GetAll();

        /// <summary>
        /// Find queries by predicate
        /// </summary>
        /// <param name="predicate">search predicate (LINQ)</param>
        /// <returns>IQueryable queries</returns>
        IQueryable<T> FindBy(Expression<Func<T, bool>> predicate);

        /// <summary>
        /// Find entity by keys
        /// </summary>
        /// <param name="keys">search key</param>
        /// <returns>T entity</returns>
        Task<T> FindAsync(params object[] keys);

        /// <summary>
        /// Add new entity
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task AddAsync(T entity);

        /// <summary>
        /// Remove entity from database
        /// </summary>
        /// <param name="entity"></param>
        void Delete(T entity);

        /// <summary>
        /// Remove entity from database
        /// </summary>
        /// <param name="keys">entity keys</param>
        void Delete(params object[] keys);

        /// <summary>
        /// Edit entity
        /// </summary>
        /// <param name="entity"></param>
        Task UpdateAsync(T entity);

        /// <summary>
        /// Persists all updates to the data source.
        /// </summary>
        void SaveChanges();
        Task SaveChangesAsync();
    }

GenericRepository:

代码语言:javascript
复制
 public class GenericRepository<T> : IGenericRepository<T> where T : BaseEntity
    {
        private readonly DbContext _context;
        private readonly DbSet<T> _dbSet;

        public GenericRepository(DbContext context)
        {
            _context = context;
            _dbSet = context.Set<T>();
        }
        public virtual async Task<T> FirstAsync(Expression<Func<T, bool>> predicate)
        {
            return await _dbSet.FirstAsync(predicate);
        }

        public virtual async Task <T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate)
        {
            return await _dbSet.FirstOrDefaultAsync(predicate);
        }

        public virtual IQueryable<T> GetAll()
        {
            return _dbSet.AsNoTracking();
        }

        public virtual IQueryable<T> FindBy(Expression<Func<T, bool>> predicate)
        {
            return _dbSet.Where(predicate);
        }

        public async Task<T> FindAsync(params object[] keys)
        {
            return await _dbSet.FindAsync(keys);
        }

        public virtual async Task AddAsync(T entity)
        {
            await _dbSet.AddAsync(entity);
        }

        public virtual void Delete(T entity)
        {
            _dbSet.Remove(entity);
        }

        public virtual void Delete(params object[] keys)
        {
            var entity = _dbSet.Find(keys);
            _dbSet.Remove(entity);
        }

        public virtual async Task UpdateAsync(T entity)
        {
            var existing = await _dbSet.FindAsync(entity.Id);
            if (existing != null)
            {
                existing.ModifiedDate = DateTime.UtcNow;
                _context.Entry(existing).CurrentValues.SetValues(entity);
                _context.Entry(existing).Property("AddedDate").IsModified = false;
            }
        }

        public virtual void SaveChanges()
        {
            _context.SaveChanges();
        }

        public virtual async Task SaveChangesAsync()
        {
            await _context.SaveChangesAsync();
        }
    }

CommonService:

代码语言:javascript
复制
   public class CommonService<T> : ICommonService<T> where T : BaseEntity
    {
        private readonly IGenericRepository<T> _repository;

        public CommonService(IGenericRepository<T> repository)
        {
            _repository = repository;
        }

        public virtual async Task<T> FirstAsync(Expression<Func<T, bool>> predicate)
        {
            return await _repository.FirstAsync(predicate);
        }

        public virtual async Task<T> FirstOrDefaultAsync(Expression<Func<T, bool>> predicate)
        {
            return await _repository.FirstOrDefaultAsync(predicate);
        }

        public virtual IQueryable<T> GetAll()
        {
            return _repository.GetAll();
        }

        public virtual IQueryable<T> FindBy(Expression<Func<T, bool>> predicate)
        {
            return _repository.FindBy(predicate);
        }

        public async Task<T> FindAsync(params object[] keys)
        {
            return await _repository.FindAsync(keys);
        }

        public virtual async Task AddAsync(T entity)
        {
            await _repository.AddAsync(entity);
            await _repository.SaveChangesAsync();
        }

        public virtual async Task DeleteAsync(T entity)
        {
            _repository.Delete(entity);
            await _repository.SaveChangesAsync();
        }

        public virtual async Task DeleteAsync(params object[] keys)
        {
            var entity = await _repository.FindAsync(keys);
            _repository.Delete(entity);
            await _repository.SaveChangesAsync();
        }

        public virtual async Task UpdateAsync(T entity)
        {
            await _repository.UpdateAsync(entity);
            await _repository.SaveChangesAsync();
        }
    }

ConcreteService:

代码语言:javascript
复制
public class DepartmentService : CommonService<Department>, IDepartmentService
    {
        private readonly IGenericRepository<Department> _repository;

        public DepartmentService(IGenericRepository<Department> repository) : base(repository)
        {
            _repository = repository;
        }
    }

问题:

  1. 使用共享服务作为基类以避免重复代码是一种良好的实践吗?
  2. 如果所有必要的操作都在基类(CommonService)中,或者在这种情况下,总是使用公共服务(注入ICommonService<EntityName>和使用,并创建特定的服务类,只有在其中存在特定的“不可泛型”逻辑时),那么我是否需要创建空服务?
EN

回答 1

Code Review用户

发布于 2019-09-12 19:42:18

评论

  • 您的设计为每个实体使用了专用的存储库和服务。这在一开始看起来是个好主意,但是你很快就会意识到这个设计的缺点。
  • 将服务作为存储库的美化包装器并不会给服务增加多少价值。
  • 我想问一项服务是否应该产生IQueryable。我发现一个服务负责您的域的封装。相反,返回物化集合。
  • 需要数据查找的端点应该直接调用存储库,而需要业务逻辑的端点应该传递服务。

仓库

存储库是两者中的较低层。我可以想象一个实体的存储库是有意义的。但是,您可能会遇到一些相互矛盾的担忧。假设我们有一个实体Offer,其中包含一个OfferLines列表。当我们保存报价时,哪个存储库负责什么?

  • OfferRepository保存报价,而报价行由OfferLineRepository保存吗?
  • OfferRepository与所有子实体一起保存优惠?
  • 两个存储库都允许保存提供行吗?

服务

服务是较高级别的层。按实体定义服务可能过于技术性。将服务视为特性的外观,或一组相关概念。拥有OfferService和OfferLineService对我来说没有意义。

骨料根

更有意义的设计是为一组实体选择一个聚合根。这些实体可能包括表示表、视图、复杂类型和仅内存类的类,这些类都具有相同的概念。我会这样设计这两个层:OfferRepository和OfferService。OfferLines是聚合根Offer的一部分。

所以是否值得使用公共服务和存储库..。我认为是的,但重点是按功能分组,而不是按实体类型分组。

票数 5
EN
页面原文内容由Code Review提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://codereview.stackexchange.com/questions/171162

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档