Question

我有以下示例，我想知道何时将其拆分为其他存储库。我有一个包含类别，产品系列和产品类型的产品列表。你可以添加，删除和编辑所有这些，但这项服务是否做得太多了？：

public interface IProductService : IServiceBase
{
    void DeleteProductCategory(int productCategoryId);
    IEnumerable<ProductCategory> GetAllProductCategories();
    IEnumerable<ProductCategory> GetDisplayedProductCategories();
    ProductCategory GetProductCategory(int productCategoryId);
    ProductCategory SaveProductCategory(ProductCategory productCategory);

    void DeleteProductLine(int productLineId);
    IEnumerable<ProductLine> GetAllProductLines();
    IEnumerable<ProductLine> GetDisplayedProductLines();
    ProductLine GetProductLine(int productLineId);
    ProductLine SaveProductLine(ProductLine productLine);

    void DeleteProductType(int productTypeId);
    IEnumerable<ProductType> GetAllProductTypes();
    IEnumerable<ProductType> GetDisplayedProductTypes();
    ProductType GetProductType(int productTypeId);
    ProductType SaveProductType(ProductType productType);

    IEnumerable<Product> GetProductsByCategory(int productCategoryId);
    IEnumerable<Product> GetProductsByLine(int productLineId);
    IEnumerable<Product> GetProductsByType(int productTypeId);
}

我正在使用存储库模式，所以现在我必须为此注入所有存储库：

public ProductService(
        IRepository<Product> productRepo,
        IRepository<ProductCategory> productCategoryRepo,
        IRepository<ProductLine> productLineRepo,
        IRepository<ProductType> productTypeRepo,
        IValidationService validationService,
        IUnitOfWork unitOfWork
        )
        : base(validationService, unitOfWork)
    {
        Enforce.ArgumentNotNull(productRepo, "productRepo");
        Enforce.ArgumentNotNull(productCategoryRepo, "productCategoryRepo");
        Enforce.ArgumentNotNull(productLineRepo, "productLineRepo");
        Enforce.ArgumentNotNull(productTypeRepo, "productTypeRepo");

        this.productRepo = productRepo;
        this.productCategoryRepo = productCategoryRepo;
        this.productLineRepo = productLineRepo;
        this.productTypeRepo = productTypeRepo;
    }

对我而言，这是很多依赖关系。何时/如何将它们分开？

Answer 1

我个人希望创建一些基本的通用服务类，然后从中继承一些服务。像这样的东西

public abstract class GeneralService<T>
{
    private IRepository<T> _repository;
    public GeneralService(IRepository<T> repository)
    {
        _repository = repository;
    }

    public abstract void Delete(int Id);
    public abstract IEnumerable<T> GetAll();
    public abstract IEnumerable<T> GetDisplayed();
    public abstract T Get(int Id);
    public abstract T Save(T t);

    public abstract IEnumerable<Product> GetProducts(int Id);
}

public interface IRepository<T>
{
    ...
}

和

public class ProductService : GeneralService<Product>
{
    ...
}

public class ProductLineService:GeneralService<ProductLine>
{
    ...
}

聚合存储库/服务模式

1 个答案: