Question

我有一个基类C1，它提供了几个方法的默认实现，如C2和许多自定义实现Cx（+20），如下所示：< / p>

abstract class C1
{
    public abstract void M1();
}

abstract class C2 : C1
{
    // other overridden members ...

    // M1(); has no default implementation yet.
}

class Cx : C2
{
    public override void M1()
    {
        // ...
    }
}

现在，我想链接C2.M1和Cx.M1，因为我需要添加新的常用功能。通常，我会创建一个新的抽象方法，并由第二个 base 类调用它，如下所示：

abstract class C1
{
    public abstract void M1();
}

abstract class C2 : C1
{   
    // M1 should get a default implementation 
    // and then M1 in the next derived class should be called
    public override void M1()
    {
        // ...
        M1Internal();
    }

    protected abstract void M1Internal();
}

class Cx : C2
{
    protected override void M1Internal()
    {
        // ...
    }
}

但是，我有20多个这样的类，并且要全部更新它们，所以我想知道是否还有另一种方法可以让我覆盖M1和{{ 1}}，然后依次C2和Cx先调用它们，而无需创建新的 intermediate 帮助器方法。对于这种情况有更好的模式吗？

Answer 1

我认为在这种情况下最好使用装饰器模式。尽可能使用合成而不是继承。

abstract class C1
{
    public abstract void M1();
}

class Cx : C1
{
    public override void M1()
    {
        // ...
    }
}

class CxWithCommonBehavior : C1
{
    C1 realObject;

    public CxWithCommonBehavior(C1 realObject)
    {
        this.realObject = realObject;
    }

    public override void M1()
    {
        // common behavior
        realObject.M1();
    }
}

请注意，对于所有派生的Cx类，您只需要一个CxWithCommonBehavior类-您在构造函数中传递经过修饰的实例。

这样，您可以添加更多行为，以所有可能的方式链接它们，甚至在运行时添加或删除它们。

Answer 2

仅在base.M1处调用Cx.M1怎么办？

class Cx : C2
{
    protected override void M1()
    {
        base.M1();//i.e. C2.M1()
        //Cx.M1 internal logic
    }
}

在多个类中一个接一个地调用相同的重写方法

2 个答案: