C# 聚合存储库/服务模式

下面是一个例子，我想知道什么时候把它拆分成其他存储库。我有一个产品列表，其中包括类别、产品线和产品类型。您可以添加、删除和编辑所有这些内容，但这项服务是否做得太多了

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);
}

公共接口IPProductService:IServiceBase
{
void DeleteProductCategory（int-productCategoryId）；
IEnumerable GetAllProductCategories（）；
IEnumerable GetDisplayedProductCategories（）；
ProductCategory GetProductCategory（int-productCategoryId）；
ProductCategory保存ProductCategory（ProductCategory ProductCategory）；
void DeleteProductLine（int productLineId）；
IEnumerable GetAllProductLines（）；
IEnumerable GetDisplayedProductLines（）；
ProductLine GetProductLine（int productLineId）；
ProductLine SaveProductLine（ProductLine ProductLine）；
void DeleteProductType（int-productTypeId）；
IEnumerable GetAllProductTypes（）；
IEnumerable GetDisplayedProductTypes（）；
ProductType GetProductType（int productTypeId）；
ProductType SaveProductType（ProductType ProductType）；
IEnumerable GetProductsByCategory（int productCategoryId）；
IEnumerable GetProductsByLine（int productLineId）；
IEnumerable GetProductsByType（int productTypeId）；
}

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

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;
    }

公共产品服务(
i假定产品报告，
IRepository productCategoryRepo，
IRepository productLineRepo，
i推定产品类型回购，
IValidationService验证服务，
工作单位
)
：base（validationService，unitOfWork）
{
Enforce.ArgumentNotNull（productRepo，“productRepo”）；
Enforce.ArgumentNotNull（ProductCategoryReporto，“ProductCategoryReporto”）；
Enforce.ArgumentNotNull（productLineRepo，“productLineRepo”）；
Enforce.ArgumentNotNull（productTypeRepo，“productTypeRepo”）；
this.productRepo=productRepo；
this.productCategoryRepo=productCategoryRepo；
this.productLineRepo=productLineRepo；
this.productTypeRepo=productTypeRepo；
}

---

在我看来，这是一个很大的依赖。何时/如何拆分它们？

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

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>
{
    ...
}

公共抽象类GeneralService
{
私人IRepository_存储库；
公共通用服务（IRepository存储库）
{
_存储库=存储库；
}
公共摘要无效删除（int-Id）；
公共抽象IEnumerable GetAll（）；
公共抽象IEnumerable GetDisplayed（）；
公共摘要T-Get（int-Id）；
公开摘要T保存（T T）；
公共抽象IEnumerable GetProducts（int-Id）；
}
公共接口假定
{
...
}

及

公共类ProductService:GeneralService
{
...
}
公共类ProductLineService:GeneralService
{
...
}

这可能需要一个真正的答案，我对此也很恼火

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

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