复杂服务层中 IoC 的最佳实践 [重复]答案

【问题标题】：Best practices for IoC in complex service layer [duplicate]复杂服务层中 IoC 的最佳实践 [重复]
【发布时间】：2014-10-23 08:41:56
【问题描述】：

我正在开发一个 MVC 应用程序，我正在使用 Unity for IoC。 My Application 基本上由 UI 层、服务层和存储库层组成。

我的典型控制器是：

public class TestController : Controller
    {
        private ITestService testServ;

        public TestController(ITestService _testServ)
        {
            testServ= _testServ;
        }

    public ActionResult Index()
    {
        testServ.DoSomething();
        return View();
    }
}

没有什么特别的，我的每个控制器都注入了一个服务对象。因此，我的服务层对象执行复杂的业务规则，聚合来自许多不同存储库的信息。通过使用 IoC，我发现我的构造函数看起来过于复杂，但由于该服务需要访问许多存储库，因此我看不到任何解决方法。

我的服务层中的一个典型类如下所示：

public class TestService : ITestService
    {
        private ITransactionRepository transRepo;
        private IAccountRepository accountRepo;
        private ISystemsRepository sysRepo;
        private IScheduleRepository schRepo;
        private IProfileRepository profileRepo;

        public TestService(ITransactionRepository _transRepo;
                           IAccountRepository _accountRepo;
                           ISystemsRepository _sysRepo;
                           IScheduleRepository _schRepo;
                           IProfileRepository _profileRepo)
        {
            transRepo = _transRepo;
            accountRepo = _accountRepo;
            sysRepo = _sysRepo;
            schRepo = _schRepo;
            profileRepo = _profileRepo;
        }

        public DoSomething()
        {
            //Implement Business Logix
        }
    }

我的几个服务层对象需要 10 个或更多存储库。我的存储库使用 Entity Framework，其中每个存储库类在底层数据存储中公开一个表。

我正在寻找一些关于在上述情况下的最佳实践的建议。

【问题讨论】：

正在寻找有关 IoC 或 DI 容器（Unity 是后者）的建议？
顺便说一句：如果您的“服务”有很多依赖项，它可能会太多（SOLID 中的S）-也许您可以将服务本身拆分为真正的职责-很可能您也可以为结果提供比 Service 更好的名称；)

标签： c# asp.net-mvc design-patterns inversion-of-control

【解决方案1】：

您已经创建了一个服务层，以便它充当底层存储库的外观。这种方法是一种很好的做法，可以使用粗略的 API 向客户端提供外观。客户不必担心底层存储库。

由于 DI 的完成方式，服务本身现在有一个复杂的构造函数。另一种方法是在 Service 层使用抽象工厂模式并进行 setter 注入。这种更新存储库的复杂性被转移到一个单独的类中，它自己的工厂。例如：

您可以如下设置测试服务的存储库而不是构造函数

public class TestService : ITestService
{
    private ITransactionRepository transRepo = DataAccess.transRepo;
    private IAccountRepository accountRepo = DataAccess.accountRepo;
    private ISystemsRepository sysRepo = DataAccess.sysRepo;
    private IScheduleRepository schRepo = DataAccess.schRepo ;
    private IProfileRepository profileRepo = DataAccess.profileRepo;
}

下面是工厂接口示例

public interface IRepoFactory
{
    ITransactionRepository TransRepo {get;}
    IAccountRepository AccountRepo {get;}
    ISystemsRepository SysRepo {get;}
    IScheduleRepository SchRepo {get;}
    IProfileRepository ProfileRepo {get;}
}

下面是一个具体工厂的示例，它将新建所有存储库。

public class EfFactory : IRepoFactory

{

    public ITransactionRepositry TransRepo { return new TransactionRepository();}

    public IAccountRepository AccountRepo {return new AccountRepository();}

    public ISystemsRepository SysRepo {return new SystemRepository();}

    public IScheduleRepository SchRepo {return new SchRepository();}

    public IProfileRepository ProfileRepo {return new ProfileRepository();}

}

下面是一个工厂方法，它将返回具体工厂（在您的情况下，它将是一个 EF 工厂）

public class RepoFactories
{
    public static IRepoFactory GetFactory(string typeOfFactory)
    {
        return (IRepoFactory)Activator.CreateInstance(Type.GetTypetypeOfFactory)
    }
}

具有静态方法的抽象工厂来新建和返回存储库对象

//示例：factoryName = MyProject.Data.EFFactory（这个可以添加到你的web.config或者app.config中）

Public static class DataAccess
{
    private static readonly string DbfactoryName=   ConfigurationManager.AppSettings.Get("factoryName");
    private static readonly IRepoFactory factory = RepoFactories.GetFactory(DbfactoryName);

    public static ITransactionRepositry transRepo
    {
        get {return factory.TransRepo;}
    }
    public static IAccountRepository accountRepo
    {
        get {return factory.AccountRepo;}
    }
}

【讨论】：

【解决方案2】：

以下是简化（和减少）依赖关系的一些步骤：

将您的服务拆分为单独的服务并将它们注入您的控制器。这将减少服务依赖的数量。缺点是您需要向控制器注入更多依赖项。下一步是在控制器变得复杂时拆分控制器。记住Single Responsibility Principle。

看看Bounded Context 模式：您可以尝试将经常在单个上下文中组合在一起的实体分组，并将该上下文注入到服务中，而不是注入数十个存储库：

public class TestService : ITestService
{
    private readonly ITestData testData; // represents a bounded context

    public TestService(ITestData testData)
    {
        this.testData = testData;
    }

    public void DoSomething()
    {
        this.testData.Transactions.Add(...); //It gives you access to Transactions repository
    }
}

【讨论】：