从抽象类派生时如何避免组合类爆炸？

如何解决从抽象类派生时如何避免组合类爆炸？

最近从抽象类派生后，我意识到我开始有很多类似的类，它们只改变了一种方法。我研究了避免这种情况的方法，并得出结论，Decorator pattern 可能是避免这种情况的最佳方法。

所以我必须从以下类派生：

public abstract class SlowLoadableComponent<T> : LoadableComponent<T>
        where T : SlowLoadableComponent<T>

反过来又来自：

public abstract class LoadableComponent<T> : ILoadableComponent
    where T : LoadableComponent<T>
{
    ...

    protected virtual void HandleLoadError(WebDriverException ex)
    {
    }

    protected abstract void ExecuteLoad();

    protected abstract bool EvaluateLoadedStatus();
    
    ...
}

所以在推导时，我们需要定义ExecuteLoad()和EvaluateLoadedStatus()。示例：

public abstract class ExampleSlowLoadableComponent<T> : SlowLoadableComponent<T>
    where T : ExampleSlowLoadableComponent<T>
{
    protected IWebDriver driver;

    protected ExampleSlowLoadableComponent(IWebDriver driver,TimeSpan timeout,IClock clock)
        : base(timeout,clock)
    {
        this.driver = driver;
    }

    

    protected override bool EvaluateLoadedStatus()
    {
        // evaluate loaded status logic
    }

    protected override void ExecuteLoad()
    {
        // execute load logic
    }
}

我遇到的问题是，在某些类中，ExecuteLoad() 必须更改，而在其他类中，EvaluateLoadedStatus() 是必须更改的，也许两者都必须更改。

但是我完全不知道如何做到这一点。

例如，假设我们需要从前面的 ExampleSlowLoadableComponent 派生类派生一个抽象类，该派生类需要在类中定义一个 IWebElement 类型，并且 ExecuteLoad() 更改为使用这个IWebElement：

public abstract class SlowLoadableComponentWithButton<T> : ExampleSlowLoadableComponent<T>
    where T : SlowLoadableComponentWithButton<T>
{

    protected SlowLoadableComponentWithButton(IWebDriver driver,IClock clock)
        : base(driver,timeout,clock)
    {
    }

    protected abstract IWebElement Button { get; }    

    protected override bool EvaluateLoadedStatus()
    {
        // evaluate loaded status logic
    }

    protected override void ExecuteLoad()
    {
        Button.Click();
    }
    
}

现在，我们需要一个从前一个派生的新抽象类，但这次必须将 IWebElement 注入到类构造函数中：

public abstract class SlowLoadableComponentWithButtonInjected<T> : SlowLoadableComponentWithButton<T>
    where T : SlowLoadableComponentWithButtonInjected<T>
{

    protected SlowLoadableComponentWithButtonInjected(
         IWebDriver driver,IWebElement button,IClock clock) : base(driver,clock)
    {
        Button = button;
    }

    protected override IWebElement Button { get; }    

    protected override bool EvaluateLoadedStatus()
    {
        // evaluate loaded status logic
    }
}

---

如您所见，从一个类到另一个类的变化非常小，通常只是在前一个类的基础上增加一个步骤，但是我不确定如何将这种模式更改为Decorator pattern？

感谢任何帮助。