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
}

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

方法1：

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

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

不知何故，这似乎违反了Single Responsible Principle，因为BarService用于检查Foo。所以我提出了方法2：

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

我想知道services这样依赖彼此是个好主意。请建议我以上哪种方法可以遵循或任何其他方法将有所帮助

Answer 1

我个人会避免使用其他服务的服务，因为迟早你会获得循环引用。使服务不依赖于彼此也使得耦合更松散并且易于测试。所以我会选择方法1.

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

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

希望这有帮助。

存储库的服务应该相互依赖吗？

1 个答案: