c# - 如何在基类中初始化应该在子类中初始化的字段？

Question

我的基类 Car 包含无法在基类中初始化的字段 engine。我只能在子类中初始化它，例如在 ElectricCar 中我可以编写 engine = new ElectricEngine。但是我在基类中使用字段。所以我有一个使用但未初始化的字段:

public class Car {

    protected Engine engine;

    public void Start() {
        engine.Start();
        // do something else
    }

    public void Stop {
        engine.Stop();
        // do something else
    }

    public void Diagnose() {
        engine.Diagnose();
        // anotherField.Diagnose();
        // oneAnotherField.Diagnose();
    }

}

如何更好的初始化引擎？

Version 1. Field 保证被初始化但是有很多字段构造函数看起来很难看。没有错误但丑陋。

public class Car {

    protected Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void Start() {
        engine.Start();
        // do something else
    }

    public void Stop {
        engine.Stop();
        // do something else
    }

    public void Diagnose() {
        engine.Diagnose();
        // anotherField.Diagnose();
        // oneAnotherField.Diagnose();
    }

}

public class ElectricCar : Car {
    public ElectricCar() : base (new ElectricEngine()) {
    }
}

版本 2. 子类应该记住初始化字段，与子类有这样的“契约”可能会引入错误(未初始化的字段)。

public class Car {

    protected Engine engine;

    public Car() {
    }

    public void Start() {
        engine.Start();
        // do something else
    }

    public void Stop {
        engine.Stop();
        // do something else
    }

    public void Diagnose() {
        engine.Diagnose();
        // anotherField.Diagnose();
        // oneAnotherField.Diagnose();
    }

}

public class ElectricCar : Car  {
    public ElectricCar() {
        engine = new ElectricEngine();
    }
}

版本 3. 字段保证被初始化。构造函数很清楚。但是从构造函数调用虚方法(有潜在危险，一般不推荐)。

public class Car {

    protected Engine engine;

    public Car() {
        InitializeEngine();
    }

    protected abstract void InitializeEngine();

    public void Start() {
        engine.Start();
        // do something else
    }

    public void Stop {
        engine.Stop();
        // do something else
    }

    public void Diagnose() {
        engine.Diagnose();
        // anotherField.Diagnose();
        // oneAnotherField.Diagnose();
    }

}

public class ElectricCar : Car  {
    public ElectricCar() {
    }

    protected void override InitializeEngine() {
        engine = new ElectricEngine();
    }
}

所以每个版本都有利有弊。哪个版本更好？或者您甚至可以提出其他建议。

Answer 1

版本 3 是对 Template method design pattern 的一种改造.如果你的基类不能提供一个合理的默认实现，但你又要求每辆车都有一个引擎，那么将创建委托(delegate)给基类是一个非常合适和安全的解决方案。我会稍微调整你的初始化是这样的:

protected abstract Engine InitializeEngine();

然后在 Car 的构造函数中:

public Car() {
    engine = InitializeEngine();
}

这将使契约(Contract)非常明确。您的子类只需要提供一个引擎，您的基类将保证在调用构造函数后分配引擎变量。