C＃中多态性的复杂问题

Question

我正在构建一个允许制造商输入汽车规格的应用程序。现在，假设我输入汽车的名称（存储在Car表中），*引擎的类型（存储在为该类型的引擎指定的表中）

*注意：由于引擎表的结构不同，每个引擎必须存储在一个单独的表中。例如，如果汽车的发动机是4 Cyl，它必须存储在4 Cyl表中。

在应用程序中，有一个功能允许制造商返回并修改/查看汽车规格。在此功能中，当他/她点击“查看汽车”时，4 Cyl汽车会显示自己的规格，6 Cyl汽车有自己的规格，依此类推。现在，问题是当我检索数据时，如何为每辆车分配正确的引擎对象。

我可以使用任何设计模式来解决这个问题吗？

Answer 1

我认为你的问题是那些需要使用抽象工厂设计模式来解决它们的常见问题。抽象工厂模式提供了一个接口来封装几个具有共享主题的工厂，或者你可以说抽象工厂是一个超级工厂，作为其他工厂的抽象。以下代码可能有助于解决您的问题。您可以修改代码以使其适用于您的应用程序。现在，您需要构建您的具体类：Car，4Cyl，6Cyl和8Cyl类。之后，您需要为每个引擎+汽车本身构建一个工厂类：

• 4Cyl + Car工厂
• 工厂为6Cyl + Car
• 如果您有更多类型的发动机，8Cyl + Car的工厂，等等。

  public class Car
  {
      private int _id;
  
      public Car(int id)
      {
          _id = id;
      }
  
      public Car retrieveCar()
      {
          return new Car(_id);
      }
  }

以下是引擎的接口：

public interface IEngine
{
    IEngine retrieveEngine();
}

然后，我们需要为每个引擎类型编写具体的类：

public class FourCyl : IEngine
{
    private int _id = 0;

    public FourCyl(int id)
    {
        _id = id;
    }
    public IEngine retrieveEngine()
    {
        return new FourCyl(_id);
    }
}

public class SixCyl : IEngine
{
    private int _id = 0;

    public SixCyl(int id)
    {
        _id = id;
    }

    public IEngine retrieveEngine()
    {
        return new SixCyl(_id);
    }
}

public class EightCyl : IEngine
{
    private int _id =0;

    public EightCyl(int id)
    {
        _id = id;
    }
    public IEngine retrieveEngine()
    {
        return new EightCyl(_id);
    }
}

注意：您可以通过编写自己的从数据库中检索数据的代码来替换创建新对象的代码，例如“return new EightCyl（_id）”。

现在，我们需要编写抽象工厂的代码：

interface ICarFactory
{
    Car car();
    IEngine engine();
}

然后，我们需要列出或编写所有工厂类：

class FourCylCarFactory : ICarFactory
{
    private int _carId;
    private int _engineId;

    public FourCylCarFactory(int carID, int engineID)
    {
        _carId = carID;
        _engineId = engineID;
    }

    public Car car()
    {
        Car carObject = new Car(_carId);
        return carObject.retrieveCar();
    }

    public IEngine engine()
    {
        FourCyl engineObject = new FourCyl(_engineId);
        return engineObject.retrieveEngine();
    }
}

class SixCylCarFactory : ICarFactory
{
    private int _carId;
    private int _engineId;

    public SixCylCarFactory(int carID, int engineID)
    {
        _carId = carID;
        _engineId = engineID;
    }

    public Car car()
    {
        Car carObject = new Car(_carId);
        return carObject.retrieveCar();
    }

    public IEngine engine()
    {
        SixCyl engineObject = new SixCyl(_engineId);
        return engineObject.retrieveEngine();
    }

}

class EightCylCarFactory : ICarFactory
{
    private int _carId;
    private int _engineId;

    public EightCylCarFactory(int carID, int engineID)
    {
        _carId = carID;
        _engineId = engineID;
    }

    public Car car()
    {
        Car carObject = new Car(_carId);
        return carObject.retrieveCar();
    }

    public IEngine engine()
    {
        EightCyl engineObject = new EightCyl(_engineId);
        return engineObject.retrieveEngine();
    }
}

最后，在创建工厂之后，您可以通过创建汽车来开始使用它们，例如以下代码：

class CarSystem
{
    public void createCar(int carID, int engineID)
    {
        ICarFactory carFactory = new EightCylCarFactory(carID, engineID);

        Car car = carFactory.car();
        IEngine engine = carFactory.engine();
    }
}

通过这种方式，多态性以良好的方式应用，并且您可以为将来出现的每种新引擎类型创建新工厂，以便轻松地遵守许多OO原则，如OCP原则（开放/封闭原则）。打开以扩展/添加和关闭更改。