c# - Repositories 的服务应该相互依赖吗？

Question

假设我有 2 个实体 Foo 和 Bar，如下所示:

public class Foo
{
    public int FooID {get;set;}
    public string FooName {get;set;}
}

public class Bar
{
    public int BarID {get;set;}
    public string BarName {get;set;}
    public int FooID {get;set;}
}

对于每个实体都会有它的存储库:

public class FooRepository
{
    public IEnumerable<Foo> getFoo()
    {
        //do something
    }
}

public class BarRepository
{
    public IEnumerable<Bar> getBar()
    {
        //do something
    }

    public IEnumerable<Bar> getBar(int FooID)
    {
        //get bar base on foo id
    }
}

这些存储库中的每一个都会有一个关联的服务:

public class FooService
{
    //depend on Foo repository
}

public class BarService
{
    //depend on Bar repository
}

现在我想创建一个函数来查看 Bar 中是否使用了 Foo。我想到了2种方法来实现这个功能:

方法一:

public class BarService
{
    private BarRepository repository = new BarRepository();

    public bool isFooExisted(int FooID)
    {
        var bars = this.repository.getBar(FooID);
        return bars.Count > 0;
    }
}

不知何故，这看起来违反了单一责任原则，因为BarService 用于检查Foo。所以我想出了方法2:

方法二:

public class BarService
{
    private BarRepository repository = new BarRepository();

    public IEnumerable<Bar> getBar(int FooID)
    {
        return this.repository.getBar(FooID);
    }
}

public class FooService
{
    private BarService service = new BarService();

    public bool isFooExisted(int FooID)
    {
        var bars = service.getBar(FooID);
        return bars.Count > 0;
    }
}

我想知道服务像这样相互依赖是不是个好主意。请建议我采用上述方法中的哪一种是好的，或者任何其他方法都会有所帮助

Answer 1

我个人会避免使用其他服务的服务，因为迟早你会得到一个循环引用。让服务不相互依赖也有利于松耦合和易于测试。所以我会选择方法 1。

当您想要在服务之间重用功能时，这种方法就会出现问题。在您的情况下，您可以推迟对相应存储库的调用，但在更复杂的情况下，您可能需要添加一个包含可在不同服务中重复使用的通用业务逻辑的域对象。例如，如果你必须在两个服务中都有一个复杂的 isFooExisted 方法，你可能会做这样的事情(请注意，我已经更改了你的代码以使用依赖注入(inject)来使你的代码更易于测试):

public class BarService
{
    private FooEntity fooEntity;

    public BarService(IFooRepository repository)
    {
        this.fooEntity = new FooEntity(repository);
    }

    public IEnumerable<Foo> getFoo(int FooID)
    {
        return fooEntity.getFoo(FooID);
    }
}

public class FooService
{    
    private FooEntity fooEntity;

    public FooService(IFooRepository repository)
    {
        this.fooEntity = new FooEntity(repository);
    }

    public IEnumerable<Foo> getFoo(int FooID)
    {
        return fooEntity.getFoo(FooID);
    }
}

public class FooEntity
{
    private IFooRepository repository;

    public FooEntity(IFooRepository repository)
    {
        this.repository = repository;
    }

    public bool isFooExisted(int FooID)
    {
        /** Complex business logix **/
    }
}

对于简单的情况，我只是直接使用同一个存储库，而没有域对象:

public class BarService
{
    private IFooRepository repository;

    public BarService(IFooRepository repository)
    {
        this.repository = repository;
    }
    ...
}

public class FooService
{    
    private IFooRepository repository;

    public FooService(IFooRepository repository)
    {
        this.repository = repository;
    }
    ...
}

希望这对您有所帮助。