c# - 面向对象设计之谜

Question

假设您有一个abstract base class从其他类 X 继承 的 A。

A 类覆盖方法foo1。

很少有其他类 A1、A2、A3 是concrete类。

所有具体类都继承方法foo1。

方法foo1几乎就像应该适用于所有具体类的通用算法。
它“几乎”是因为算法中有一个异常存在一个 if 条件，一些类可以说只有 A1，A3 需要foo2在foo.

对于 A2，我们不需要启动foo2.

问题是，如果我foo2在 A 类中实现它的所有子级也将继承此功能，这不是很好的设计吗？

我想排除foo2将由具体类实现的接口-> 但这并不好，因为foo1哪些调用foo2在基类上！

任何想法如何以适当的方式解决这个问题？

谢谢

Answer 1

您可以拥有某种内部 Foo1 初始化程序，您可以在子类中覆盖它。

public abstract class A {
    internal virtual void Foo1Init() {
        Console.WriteLine("Foo1Init");
    }

    public void Foo1() {
        Foo1Init();
        Console.WriteLine("Foo1");
    }
}

public class A1 : A {
    internal override void Foo1Init() {
        Console.WriteLine("A1 Foo1Init Override");
    }
}

public class A2 : A {

}

public class A3 : A {
    internal override void Foo1Init() {
        Console.WriteLine("A3 Foo1Init Override");
    }
}

class Program {
    static void Main(string[] args) {
        var a1 = new A1();
        a1.Foo1();

        var a2 = new A2();
        a2.Foo1();

        var a3 = new A3();
        a3.Foo1();

        Console.ReadKey();
    }
}

输出：

A1 Foo1Init 覆盖  
Foo1  
Foo1Init
Foo1
A3 Foo1Init 覆盖  
Foo1

Answer 2

在这种情况下，我将使用的解决方案是创建另一层抽象类，需要特殊的类Foo2从中派生。

abstract class A : X
{
    public virtual void Foo()
    {
        //Foo logic
    }
}

abstract class B : A
{
    protected virtual void Foo2()
    {
        //Foo2
    }

    override void Foo()
    {
        Foo2();
        base.Foo();
    }
}

public A1 : B
{
}

public A2 : A
{
}

public A3 : B
{
}

Answer 3

在您的基类中创建一个属性，当子类需要调用 foo2() 时可以设置该属性：

public class BaseClass {
    protected bool RunFoo2 { get; set; }

    public BaseClass() {
        // Not really needed, since booleans default to false
        RunFoo2 = false;
    }

    public virtual void foo1() {
        if (RunFoo2)
            foo2();
        // Default code here
    }

    public virtual void foo2() {
        // Whatever
    }
}

public class A : BaseClass {
    public A() : base() {
        RunFoo2 = true;
    }
}