关于重构为抽象类的基本问题

Question

这可能是一个初学者问题，但是否有一种标准方法可以将 Wheel 属性的重复重构到抽象类中，但仍保持对 Part 类型的显式转换。 假设我们必须防止将 FastCarWheel 放在 SlowCar 上，并且有很多类似的属性。

abstract class Car {}

class FastCar : Car
{
    public FastCarWheel Wheel { get; set; }
} 

class SlowCar : Car
{
    public SlowCarWheel Wheel { get; set; }
} 

abstract class WheelPart {}

class FastCarWheel: WheelPart {}

class SlowCarWheel: WheelPart {}

在这种情况下，通常只允许这种类型的复制吗？ 我正在考虑使用泛型，但似乎我正在转移问题，并且对于以这种方式表现的每个附加属性来说，情况会变得更糟。

abstract class Car <P>
    where P : Part
{
    protected abstract P Wheel { get; set; }
}

谢谢

Answer 1

我认为使用 Fast 或 Slow 策略 可以帮助为给定的汽车类型安装正确的车轮（其中 Car 和 Wheel 都依赖于政策和 Car比如说，对象有一个私人的轮子集合）。

Answer 2

此解决方案不是多态的，但如果您需要基类级别的可见性，则可能是您唯一的选择：

abstract class Car
{
    private CarWheel wheel;
    public CarWheel Wheel
    {
        get { return wheel; }
        protected set { wheel = value; }
    }
}

class FastCar : Car
{
    public new FastCarWheel Wheel
    {
        get { return base.Wheel as FastCarWheel; }
        set { base.Wheel = value; }
    }
}

class SlowCar : Car
{
    public new SlowCarWheel Wheel
    {
        get { return base.Wheel as SlowCarWheel ; }
        set { base.Wheel = value; }
    }
}

您可能想要评估您的基类是否做得太多。 通过将您的班级分成许多较小的班级，也许可以解决您的问题。 另一方面，有时这是不可避免的。

Answer 3

由于您的目标似乎是允许客户端代码将属性作为 WheelPart 取回，但仅将其设置为特定子类，因此您有几个选项。 虽然我担心他们都不是很干净。

首先，如果设置了错误的类型，您可能会抛出运行时错误：

    public abstract class Car
    {
        public abstract WheelPart Wheel { get; set; }
    }

    public class FastCar : Car
    {
        private FastWheel _wheel;
        public override WheelPart Wheel
        {
            get { return _wheel; }
            set
            {
                if (!(value is FastWheel))
                {
                    throw new ArgumentException("Supplied wheel must be Fast");
                }
                _wheel = (FastWheel)value;
            }
        }
    }

但我不会这样做，因为客户端代码非常不清楚任何其他类型的轮子都会抛出异常，并且它们不会得到编译器反馈。

否则，您可以将属性的 Getter 和 Setter 分开，以便所需的类型非常清晰：

    public abstract class Car
    {
        public abstract WheelPart Wheel { get; }
    }

    public class FastCar : Car
    {
        private FastWheel _wheel;
        public override WheelPart Wheel
        {
            get { return _wheel; }
        }

        public void SetWheel(FastWheel wheel)
        {
            _wheel = wheel;
        }
    }

这对客户端来说更加清晰，而且如果您绝对必须将 getter 公开为 WheelPart 基类，恕我直言，这是一个更好的解决方案。

Answer 4

我会创建一个 ICar，然后以这种方式定义你的汽车，而不是抽象类

interface ICar
{
   IWheel Wheel {get; set;}
}

class FastCar: ICar
{
   FastWheel fastWheel;
   IWheel Wheel
   {
      get { return fastWheel; }
      set
      {
          if (value is FastWheel) fastWheel = (FastWheel)value;
      }    
   }         
}

class SlowCar: ICar
{
   SlowWheel slowWheel;
   IWheel Wheel
   {
      get { return slowWheel; }
      set
      {
          if (value is SlowWheel ) slowWheel = (SlowWheel )value;
      }    
   } 
}

class FastWheel: IWheel {}
class SlowWheel: IWheel {}

Answer 5

定义车轮接口 (IWheel)：

public interface IWheel
{
}

实现 FastCarWheel 和 SlowCarWheel 的接口，例如

public class FastCarWheel : IWheel
{
}

现在您的抽象类变为：

abstract class Car 
{
 public IWheel Wheel { get; set; }
}

Car 的子类可以自由使用它们选择的任何 Wheel 实现：

FastCar fastCar = new FastCar();
fastCar.Wheel = new FastCarWheel();