.NET Core中Repository/Service模式循环引用问题求解

你的LoadService和CustomerService通过构造函数注入形成互相依赖，导致DI容器无法完成实例化。以下是几种兼顾单一职责原则的解决方案：

1. 提取交叉逻辑到独立服务（最优解，完全符合SRP） #

先梳理两个服务互相调用的具体业务场景：比如LoadService调用CustomerService可能是为了获取客户信用等级，CustomerService调用LoadService可能是为了统计客户关联的负载数据。把这些不属于自身核心职责的交叉逻辑抽离成独立的专用服务：

比如新增两个细粒度服务：

• CustomerInfoService：专门封装客户信息查询、信用校验等可复用逻辑
• LoadStatsService：专门封装负载统计、状态查询等可复用逻辑

然后修改原服务依赖：

• LoadService不再注入ICustomerService，改为注入CustomerInfoService获取所需客户数据
• CustomerService不再注入ILoadService，改为注入LoadStatsService获取所需负载数据

这样每个服务的职责更纯粹：LoadService专注于负载核心业务，CustomerService专注于客户核心业务，新服务专注于共享交叉逻辑，从根源上消除循环依赖，完全符合单一职责原则。

2. 使用延迟注入（应急过渡方案） #

如果暂时无法重构职责，可以通过Lazy<T>延迟依赖实例化，让DI容器先完成其中一个服务的初始化，实际调用时再创建另一个服务：

修改LoadService代码：

public class LoadService 
{
    private readonly LoadRepository _loadRepository;
    private readonly Lazy<ICustomerService> _customerService;

    public LoadService(
        LoadRepository loadRepository,
        Lazy<ICustomerService> customerService
    ) 
    {
        _loadRepository = loadRepository;
        _customerService = customerService;
    }    

    // 实际调用时再获取实例
    public void ProcessLoad()
    {
        var customerService = _customerService.Value;
        // 调用业务方法
    }
}

CustomerService做同样修改：

public class CustomerService 
{
    private readonly CustomerRepository _customerRepository;
    private readonly Lazy<ILoadService> _loadService;

    public CustomerService(
        CustomerRepository customerRepository,
        Lazy<ILoadService> loadService
    ) 
    {
        _customerRepository = customerRepository;
        _loadService = loadService;
    }    

    public void UpdateCustomer()
    {
        var loadService = _loadService.Value;
        // 调用业务方法
    }
}

这种方式仅解决实例化问题，未优化职责划分，适合临时过渡，长期建议用第一种方案重构。

3. 调整调用链路，由上层协调 #

思考业务流程：是否可以将服务间的互相调用转移到上层（如API控制器、应用层）来协调？比如：

• 原LoadService需要先调用CustomerService获取数据再处理负载，改为由API层先调用CustomerService拿到数据，再作为参数传给LoadService的方法
• 同理，CustomerService需要的负载数据，也由上层先调用LoadService获取后传入

示例代码（API层）：

public class LoadController
{
    private readonly ILoadService _loadService;
    private readonly ICustomerService _customerService;

    public LoadController(ILoadService loadService, ICustomerService customerService)
    {
        _loadService = loadService;
        _customerService = customerService;
    }

    public async Task<IActionResult> ProcessCustomerLoad(int customerId)
    {
        // 上层协调，先获取客户数据
        var customer = await _customerService.GetCustomerById(customerId);
        // 传入LoadService处理
        await _loadService.ProcessLoadForCustomer(customer);
        return Ok();
    }
}

这种方式让服务只专注于自身核心业务，依赖由上层注入，避免了服务间的直接循环依赖。

内容的提问来源于stack exchange，提问作者Dicpherrr