Question

Class Diagram

我正在构建一个允许制造商输入汽车规格的应用程序。现在，假设我输入汽车的名称（存储在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);
    }
}

注意：您可以替换创建新对象的代码，例如＆＃34; 返回新的EightCyl（_id）＆＃34;编写自己的代码，从数据库中检索数据。

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

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原则（Open /封闭原则）开放以扩展/添加和接近变化。

C＃中多态性的复杂问题

1 个答案: