如何解决服务层内部的循环依赖关系[重复]

Question

我知道其他人已经遇到过同样的问题，但我找不到任何令人满意的解决方案，所以我在这里寻求其他想法。

我的业务逻辑包含在这样的服务层中：

public class RoomService : IRoomService
{
    private readonly IRoomRepository _roomRepository;
    private readonly ICourseService _courseService;

    public RoomService(IRoomRepository roomRepository, ICourseService courseService)
    {
        _roomRepository = roomRepository ?? throw new ArgumentNullException(nameof(roomRepository));
        _courseService = courseService ?? throw new ArgumentNullException(nameof(courseService));
    }

    public Task DeleteRoomAsync(string id)
    {
        // Check if there are any courses for this room (requires ICourseService)
        // Delete room
    }
}

public class CourseService : ICourseService
{
    private readonly ICourseRepository _courseRepository;
    private readonly IRoomService _roomService;

    public CourseService(ICourseRepository courseRepository, IRoomService roomService)
    {
        _courseRepository = courseRepository ?? throw new ArgumentNullException(nameof(courseRepository));
        _roomService = roomService ?? throw new ArgumentNullException(nameof(roomService));
    }

    public Task GetAllCoursesInBuilding(string buildingId)
    {
        // Query all rooms in building (requires IRoomService)
        // Return all courses for these rooms
    }
}

这只是一个例子。在这种情况下，可能有一些解决方法可以避免服务相互依赖，但我过去遇到过多种其他情况，没有任何干净的解决方法。

如你所见，这两个服务相互依赖，依赖注入会因为循环依赖而失败。

现在我可以想出两种方法来解决这个问题：

解决方案 1

我可以解决需要它们的服务方法内部的服务依赖关系，而不是将服务依赖关系注入服务构造函数：

public class RoomService : IRoomService
{
    private readonly IRoomRepository _roomRepository;
    private readonly IServiceProvider _serviceProvider;

    public RoomService(IRoomRepository roomRepository, IServiceProvider serviceProvider)
    {
        _roomRepository = roomRepository ?? throw new ArgumentNullException(nameof(roomRepository));
        _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
    }

    public Task DeleteRoomAsync(string id)
    {
        ICourseService courseService = _serviceProvider.GetRequiredService<ICourseService>();

        // Check if there are any courses for this room (requires ICourseService)
        // Delete room
    }
}

问题：这使得单元测试更加困难，因为我需要注入一个模拟的IServiceProvider，它能够将我的ICourseService 解析到类构造函数中。在编写单元测试时也不是很清楚，每个服务方法需要哪些服务，因为这完全依赖于实现。

解决方案 2

服务方法可能要求 ICourseService 作为方法参数从控制器传入：

public Task DeleteRoomAsync(ICourseService courseService, string id)
{
    // Check if there are any courses for this room (requires ICourseService)
    // Delete room
}

问题：现在我的控制器需要了解服务方法的实现细节：DeleteRoomAsync 需要一个 ICourseService 对象来完成它的工作。 我认为这不是很干净，因为DeleteRoomAsync 的要求将来可能会改变，但方法签名不应该。

您能想出其他更清洁的解决方案吗？

Answer 1

在提供的示例中，我会重新考虑在这种情况下您是否真的存在服务间依赖关系：

• 您的RoomService 实现中是否需要ICourseService 中包含的逻辑，还是只需要某些课程的信息？

  我会说后者，所以你真正的依赖可能是ICourseRepository 使用方法ICourseRepository.FindByRoom(Room room)。

• 您的CourseService 实现中是否需要IRoomService 中包含的逻辑，还是只需要现有房间？

  在这种情况下，IRoomRepository 就足够了。

但是，这并不总是那么容易，有时您确实需要在服务层中实现逻辑（验证等）。在这些场景中，最好尝试将该行为提取到共享类而不是复制它或创建循环依赖项。

Answer 2

当然，最好的解决方案是避免循环依赖，但如果你真的被卡住了，你可以通过使用属性注入和RegisterInstance<T>(T t)（或等效的，如果你不使用 Autofac）来解决这个问题.

例如，如果您有一个相互依赖的FooService 类和一个BarService 类，您可以这样做：

public static IContainer CompositionRoot()
{
    var foo = new FooService();
    var bar = new BarService();
    foo.Bar = bar;
    bar.Foo = foo;

    var builder = new ContainerBuilder();
    builder.RegisterInstance<IFooService>( foo );
    builder.RegisterInstance<IBarService>( bar );
    builder.RegisterType<Application>().SingleInstance();
    return builder.Build();
}

这会实例化两个服务，而不需要它们的依赖关系，然后将它们设置为彼此。当它们在 IoC 容器中注册时，它们的依赖关系已经完全建立。

请参阅我的Fiddle 以获取工作示例。

Answer 3

如果您的框架支持它，您可以将注入的依赖项作为Lazy<T> 提供，这会延迟解析并允许您拥有循环依赖项。

这些服务类可能如下所示：

class FooService : IFooService
{
    protected Lazy<IBarService> _bar;

    public FooService(Lazy<IBarService> bar)
    {
        _bar = bar;
    }

    public void DoSomething(bool callOtherService)
    {
        Console.WriteLine("Hello world. I am Foo.");
        if (callOtherService)
        {
            _bar.Value.DoSomethingElse(false);
        }
    }

}

class BarService : IBarService
{
    protected Lazy<IFooService> _foo;

    public BarService(Lazy<IFooService> foo)
    {
        _foo = foo;
    }
    public void DoSomethingElse(bool callOtherService)
    {
        Console.WriteLine("Hello world. I am Bar.");
        if (callOtherService)
        {
            _foo.Value.DoSomething(false);
        }
    }
}

注册它们的代码不需要修改（至少 Autofac 不需要）：

public static IContainer CompositionRoot()
{
    var builder = new ContainerBuilder();
    builder.RegisterType<FooService>().As<IFooService>().SingleInstance();
    builder.RegisterType<BarService>().As<IBarService>().SingleInstance();
    builder.RegisterType<Application>().SingleInstance();
    return builder.Build();
}

查看DotNetFiddle 上的工作示例。

如果您的框架不支持像这样的惰性注入，您可能可以使用工厂（或任何其他延迟解析的模式）执行完全相同的操作。

另请参阅 this answer，它帮助我想出了这个解决方案。