Неиспользованный унаследованный член и метод

Question

Привет, ребята :) Я изучаю C # и хотел бы получить некоторую помощь по поводу унаследованного члена / поля. У меня есть класс под названием Car, предположим, только с одним двигателем. Однако в последнее время я хочу сделать гоночную машину с 2 и более двигателями. Поле «my_Engine», унаследованное от родительского класса, кажется не соответствующим, и я оставляю его пустым.

Проблема 1 Replace_Engine (Engine new_Engine) больше не используется в Race_Car

Задача 2 Replace_Engine (цель Engine, Engine new_Engine) можно использовать только после явного приведения к Race_Car.

У меня довольно много подклассов автомобилей. Как я могу решить это? Нужно ли переписывать их все?

Должен ли я переписать их все, достаточно ли подходит замена my_Engine на массив? Но не все автомобили имеют более одного двигателя ... использование массива кажется странным. Я совершенно запутался здесь.

Ценю всю вашу помощь:)

public class Car 
{
    //can store only one engine
    protected Engine my_Engine;

    //Changed to virtual to let Race_Car to override
    public virtual float Get_Horse_Power()
    {
        return my_Engine.max_Power;
    }

    //Changed to virtual to let Race_Car to override
    public virtual void Replace_Engine(Engine new_Engine)
    {
        my_Engine = new_Engine;
    }
}

public class Race_Car : Car
{
    protected Engine[] my_Engines;

    public override float Get_Horse_Power()
    {
        float result=0;
        for(int i = 0; i <my_Engines.Length;i++)
        {
            result+=my_Engines.max_Power;
        }
        return result;
    }

    //Don't know which engine need to be replaced
    public override void Replace_Engine(Engine new_Engine)
    {
        throw new System.NotImplementedException();
    }

    //Created a overloading method but need an explicit cast to call
    public void Replace_Engine(Engine target, Engine new_Engine)
    {
        for(int i = 0; i <my_Engines.Length;i++)
        {
            if(my_Engines[i]==target)
            {
                my_Engines[i]= new_Engine;
                return;
            }
        }
    }
}

Answer 1

Один из возможных способов сделать это - создать концепцию абстрактного Engine и позволить тому факту, что у вас может быть более одной физической единицы, обслуживающей энергию, не будет иметь никакого значения для первоначального проекта.

Вы начинаете с абстрактного класса, представляющего движок:

public abstract class Engine
{
    public Engine()
    {

    }
    internal abstract float max_Power { get; }
}

Затем вы реализуете два вида двигателей. Простой:

public class SimpleEngine : Engine
{
    private float _maxPower;

    public SimpleEngine(float maxPower)
    {
        _maxPower = maxPower;
    }


    internal override float MaxPower
    {
        get { return _maxPower; }            
    }
}

И составной:

public class CompositeEngine : Engine
{
    private List<Engine> _engines = new List<Engine>();

    public CompositeEngine(params Engine[] engines)
    {
        _engines.AddRange(engines);
    }

    internal override float MaxPower
    {
        get { return _engines.Sum(e => e.MaxPower); }             
    }
}

Использование:

var engine = new CompositeEngine(new SimpleEngine(5), new SimpleEngine(4), new SimpleEngine(3));
var car = new Car();
car.Replace_Engine(engine);            
var value = car.Get_Horse_Power();

Выход:

значение = 12

Answer 2

Базовый класс здесь предполагает в API , что существует только один движок, так что да: это будет неудобно использовать с типами, которые не придерживаются этого API.Возможно, вы могли бы сделать что-то вроде:

public virtual int EngineCount => 1;
public virtual void ReplaceEngine(Engine newEngine, int engineIndex = 0)
{
    if(engineIndex != 0) throw new ArgumentOutOfRangeException(nameof(engineIndex));
    _engine = newEngine;
}

и:

public override int EngineCount => 2;
public void override ReplaceEngine(Engine newEngine, int engineIndex = 0)
{
    switch(engineIndex)
    {
        case 1: _secondEngine = newEngine; break;
        default: base.ReplaceEngine(newEngine, engineIndex); break;
    }
}