正确使用抽象工厂模式

Question

我目前正在实现抽象工厂模式，我想知道如何为这个设计实现它。

我想使用抽象工厂模式来帮助修改车辆信息。这一信息是为客户车辆的要求时产生的。产生是根据车辆的类型来进行的。

一个对象的例子应该是这样的。(对于其他类型，如丰田、奥迪等，这将是多个不同的对象。)

public class BMW {
    string Year;
    string Make;
    string Model;
}

例如，我想修改这个对象并添加公里。只有在请求时才会进行此修改。因此，我想使用抽象工厂来帮助处理这个问题。

这就是我到目前为止所拥有的

interface IModifyVehicle
{
    public abstract BMWWithKM Modify(BMW bmw);
}

public class ModifyWithKM : IModifyVehicle
{
    public override BMWWithKM Modify(BMW bmw)
    {
        //Add KM here
    }
}
public class BMWWithKM {
    string Year;
    string Make;
    string Model;
    string KiloMeters;

    public BMWWithKM(BMW bmw){
       //Assign values
    }        
}

如果我想处理其他类型的车辆，我将如何将工厂模式与此结合起来？另外，如果我想做一个类，我可以用里程而不是公里来修改车辆信息。我怎么能把它和这个结合起来呢？

Answer 1

是一个抽象工厂，它解决了在不指定具体类的情况下创建整个产品系列的问题。

客户需要基本上能够通过“抽象工厂”来创建产品的变体，这些工厂公开了它们的创建方法。

我提供了一个演示。它不是您想要的完全相同的实现，但它演示了设计模式的概念。

首先，定义每个产品家族将实现的抽象：

 public interface IAbstractFactory 
{
    public IElectricCar GetElectricCarModel();

    public INonElectricCar GetNonElectricCarModel();
}

然后，创建一个产品的每个家族。

IAudiFactory：

  public class IAudiFactory : IAbstractFactory
{
    public IElectricCar GetElectricCarModel()
    {
        return new AudiElectricCar();
    }

    public INonElectricCar GetNonElectricCarModel()
    {
        return new NonAudiElectricCar();
    }
}

IBMWFactory：

 public class IBMWFactory : IAbstractFactory
{
    public IElectricCar GetElectricCarModel()
    {
        return new BMWElectricCar();
    }

    public INonElectricCar GetNonElectricCarModel()
    {
        return new NonBMWElectricCar();
    }
}

每个家族都将能够创建一个产品变体。

为每个变体创建一个接口：

IElectricCar：

   public interface IElectricCar
{
    public CarModel GetDetails();
}

INonElectricCar：

 public interface INonElectricCar
    {
       public CarModel GetDetails();
    }

这是将要创建的car类：

    public class CarModel
    {
        public string Year;
        public string Make;
        public string Model;
        public string KiloMeters;
    }

创建每个汽车厂类型的非电动和电动汽车创建者的实现。

     public class AudiElectricCar : IElectricCar
    {
        public CarModel GetDetails()
        {
            return new()
            {
                Year = "2021",
                Make = "China",
                Model = "Audi electric A1",
                KiloMeters = "201"
            };
        }
    }

        public class NonAudiElectricCar  : INonElectricCar
    {
        public CarModel GetDetails()
        {
            return new()
            {
                Year = "2020",
                Make = "Rand1",
                Model = "AUDI None electric A1",
                KiloMeters = "20"
            };
        }
    }

   public class BMWElectricCar : IElectricCar
    {
        public CarModel GetDetails()
        {
            return new()
            {
                Year = "2021",
                Make = "China",
                Model = "BMW electric A1",
                KiloMeters = "201"
            };
        }
    }

   public class NonBMWElectricCar : INonElectricCar
    {
        public CarModel GetDetails()
        {
            return new()
            {
                Year = "2020",
                Make = "Rand1",
                Model = "BMW None electric A1",
                KiloMeters = "20"
            };
        }
    }

完成设计模式的抽象和实现之后，创建客户端逻辑。

    class  Client
{
    INonElectricCar nonElectricCar;
    IElectricCar electricCar;

    public Client(IAbstractFactory factory)
    {
        electricCar = factory.GetElectricCarModel();
        nonElectricCar = factory.GetNonElectricCarModel();
    }

    public CarModel GetElectricCarDetails()
    {
         return electricCar.GetDetails();
    }

    public CarModel GetNonElectricCarDetails()
    {
        return nonElectricCar.GetDetails();
    }
}

只要代码成功运行，上述逻辑就不必相同。在实际操作中在逻辑中使用客户端的示例：

Client client = new Client(new IBMWFactory());

CarModel carModel = client.GetElectricCarDetails();

Console.WriteLine(carModel.Model);


CarModel carModel2 = client.GetNonElectricCarDetails();

Console.WriteLine(carModel2.Model);