C#类设计问题，使其可进行单元测试

我有一个场景，在下面代码的帮助下解释

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.

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

现在，我不知道您所处的具体环境，但根据SRP，您必须决定您所谈论的公共功能的责任是否属于单独的类。还有一些设计模式，例如，或者，您可以使用，以遵循请勿重复原则（DRY）的方式来构造代码

就我自己而言，我首先要检查是否可以删除一个存储库接口和一个处理器接口：它们看起来非常相似，例如，

IProcessorB

接口在其

FunctionB

中有一个额外的

string

参数，将其与

IProcessorA

分开。您是否可以避免这种情况（可能通过将字符串注入到实现该接口的具体类的构造函数中），从而形成一个由多个类实现的公共接口？例如，这将允许您在代码中引入

不管怎样，这些只是我的猜测，因为我不知道你正在编写的具体代码。如果您还有任何问题，请随时提问