抽象类具有空实现方法的继承类的设计模式

Question

您能否为以下场景推荐一个好的实践模式： 我有一个定义公共行为的基本抽象类和两个继承类，每个继承类都定义了一组方法，这些方法不同于另一个实现。 然后在创建代码中（假设通过配置）我为每种配置设置选择我想要的实现并调用“doWork”，我的问题是如何避免继承类中的“空”实现以防继承类选择不实现该方法。

abstract class CommonParentClass{
    public void doWork()
    {
      commonA();
      commonB();
      uniqueA();
      uniqueB();
    }
    internal  void commonA()
    {
        //do work which is same for inheriting classes
    }
    internal void commonB()
    {
       //do work which is same for inheriting classes
    }   
    abstract void uniqueA(); 
    abstract void uniqueB();
    abstract void uniqueC();    
}

class FirstChildClass:CommonParentClass
{
        protected void uniqueA()
        {
            //implementation specific to first child
        }
        protected void uniqueB()
        {
            //EMPTY
        }   
        protected void uniqueC()
        {
            //implementation specific to first child
        }       
}

class SecondChildClass:CommonParentClass
{
        protected void uniqueA()
        {
            EMPTY
        }
        protected void uniqueB()
        {
            //implementation specific to second child
        }
        protected void uniqueC()
        {
            //implementation specific to second child
        }       
}

我有大约 5/6 的方法在其中一个继承类中是空的。 我应该使用什么设计模式来克服这个问题并避免代码重复？

Answer 1

鉴于所有这些函数似乎都具有相同的签名，您可以使用Actions 的列表。

abstract class CommonParent
{
    private readonly List<Action> _funcs = new List<Action>();

    private void CommonA() { }
    private void CommonB() { }

    protected void AddAction(Action action) => _funcs.Add(action);

    protected CommonParent()
    {
        _funcs.Add(CommonA);
        _funcs.Add(CommonB);
    }

    internal void Execute()
    {
        foreach(Action action in _funcs)
            action();
    }
}

class FirstChildClass : CommonParent
{
    private void UniqueA() { }
    private void UniqueB() { }
    private void UniqueC() { }
    public FirstChildClass()
    {
        AddAction(UniqueA);
        AddAction(UniqueB);
        AddAction(UniqueC);
    }
}


class SecondChildClass : CommonParent
{
    private void UniqueD() { }
    private void UniqueE() { }
    private void UniqueF() { }
    public SecondChildClass()
    {
        AddAction(UniqueD);
        AddAction(UniqueE);
        AddAction(UniqueF);
    }
}