我在我的项目中使用了仓库/服务设计模式。我怀疑是否值得使用公共服务。
BaseEntity:
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:
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:
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:
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:
public class DepartmentService : CommonService<Department>, IDepartmentService
{
private readonly IGenericRepository<Department> _repository;
public DepartmentService(IGenericRepository<Department> repository) : base(repository)
{
_repository = repository;
}
}问题:
CommonService)中,或者在这种情况下,总是使用公共服务(注入ICommonService<EntityName>和使用,并创建特定的服务类,只有在其中存在特定的“不可泛型”逻辑时),那么我是否需要创建空服务?发布于 2019-09-12 19:42:18
IQueryable。我发现一个服务负责您的域的封装。相反,返回物化集合。存储库是两者中的较低层。我可以想象一个实体的存储库是有意义的。但是,您可能会遇到一些相互矛盾的担忧。假设我们有一个实体Offer,其中包含一个OfferLines列表。当我们保存报价时,哪个存储库负责什么?
服务是较高级别的层。按实体定义服务可能过于技术性。将服务视为特性的外观,或一组相关概念。拥有OfferService和OfferLineService对我来说没有意义。
更有意义的设计是为一组实体选择一个聚合根。这些实体可能包括表示表、视图、复杂类型和仅内存类的类,这些类都具有相同的概念。我会这样设计这两个层:OfferRepository和OfferService。OfferLines是聚合根Offer的一部分。
所以是否值得使用公共服务和存储库..。我认为是的,但重点是按功能分组,而不是按实体类型分组。
https://codereview.stackexchange.com/questions/171162
复制相似问题