Question

我在以下代码的帮助下解释了一个场景

namespace SyncDemo
{
    public interface IProcessorA
    {
        void FunctionA(int a);
        void FunctionB(string b);
    }
    public interface IProcessorB
    {
        void FunctionA(int a);
        void FunctionB();
    }
    public interface IRepositoryA
    {
        void Add();
        void Delete();
    }
    public interface IRepositoryB
    {
        void Add();
        Void Delete();
    }

    public class ProcessorA : IProcessorA
    {
        private readonly IRepositoryA _repositoryA;

        public ProcessorA(IRepositoryA repositoryA)
        {
            _repositoryA = repositoryA;
        }

        public void FunctionA(int a)
        {
            //business logic work
            _repositoryA.Add();
        }

        public void FunctionB(string b)
        {
            _repositoryA.Delete();
        }
    }

    public class ProcessorB : IProcessorB
    {
        private readonly IRepositoryA _repositoryA;
        private readonly IRepositoryB _repositoryB;

        public ProcessorB(IRepositoryA repositoryA, IRepositoryB repositoryB)
        {
            _repositoryA = repositoryA;
            _repositoryB = repositoryB;
        }

        public void FunctionA(int a)
        {
            //do the same business logic work as in FunctionA in Class ProcessorA
            _repositoryA.Add();
        }

        public void FunctionB()
        {
            _repositoryB.Delete();
        }
    }

    public class RepositoryA : IRepositoryA
    {
        //this repository is responsible to talk with 'A' data source
        public void Add()
        {
            throw new NotImplementedException();
        }

        public void Delete()
        {
            throw new NotImplementedException();
        }
    }

    public class RepositoryB : IRepositoryB
    {
        //this repository is reponsible to talk with 'B' data source
        public void Add()
        {
            throw new NotImplementedException();
        }

        public void Delete()
        {
            throw new NotImplementedException();
        }
    }
}

有一个常见的功能，我必须在调用存储库之前在两个处理器中应用相同的业务逻辑。此外，ProcessorA和ProcessorB中还有其他方法可以直接调用存储库，因为没有要应用的业务逻辑。

我的困境是将通用业务逻辑功能代码放在何处。我应该在静态方法中创建一个具有该常用功能的单独类，还是应该创建一个单独的类，该类负责与RepositoryA交谈并执行业务逻辑？

感谢任何想法和帮助。提前谢谢。

Suyog。

Answer 1

如果您遵循面向对象的设计指南，如SOLID原则和DRY等其他原则，您应该了解单一责任原则（SRP），该原则规定一个班级应该只有一个责任（目的），因此只有一个改变的理由。

现在我不知道您正在使用的具体上下文，但根据SRP，您必须确定您所讨论的常用功能的责任是否属于单独的类。还有一些设计模式，例如Template Method Pattern或Strategy Pattern，您可以使用它来构建代码，使其遵循不要重复自己的原则（DRY）。

对于我自己，我首先要检查是否可以消除其中一个存储库接口和一个处理器接口：它们看起来非常相似，例如IProcessorB界面在其string中只有一个FunctionB参数，用于将其与IProcessorA分开。你可以避免这种情况（可能是通过将字符串注入到实现此接口的具体类的构造函数中），从而形成一个由多个类实现的公共接口吗？例如，这可以让您在代码中引入Decorator Pattern。

无论如何，这些只是我的猜测，因为我不知道你正在研究的具体代码。如果您有任何其他问题，请随时提出。

C＃类设计问题以使其可单元测试

1 个答案: