从工厂模式到抽象工厂模式

Question

我的产品工厂

public interface IProductFactory
{
    void Drive(int miles);
}

我的汽车工厂

public interface IVehicleFactory
{
    IProdctFactory GetVehicle(string Vehicle);
}

产品自行车

class Bike:IProdctFactory
{
    public void Drive(int miles)
    {
        Console.WriteLine("Drive the Bike : " + miles.ToString() + "km");
    }
}

产品指示器

class Scooter:IProdctFactory
{
    public void Drive(int miles)
    {
        Console.WriteLine("Drive the Scooter : " + miles.ToString() + "km");
    }
}

产品车

class Car:IProdctFactory
{
    public void Drive(int miles)
    {
        Console.WriteLine("Drive the Car : " + miles.ToString() + "km");
    }
}

产品吉普

class Jeep:IProdctFactory
{
    public void Drive(int miles)
    {
        Console.WriteLine("Drive the Jeep : " + miles.ToString() + "km");
    }
}

两个惠勒工厂

public class TwoWheelerFactory : IVehicleFactory
{

    public IProdctFactory GetVehicle(string Vehicle)
    {
        switch (Vehicle)
        {
            case "Scooter":
                return new Scooter();
            case "Bike":
                return new Bike();
            default:
                throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Vehicle));
        }
    }
}

四轮车厂

class FourWheelerFactory:IVehicleFactory
{

    public IProdctFactory GetVehicle(string Vehicle)
    {
        switch (Vehicle)
        {
            case "Car":
                return new Car();
            case "Jeep":
                return new Jeep();
            default:
                throw new ApplicationException(string.Format("Vehicle '{0}' cannot be created", Vehicle));
        }
    }
}

客户端

class Program
{
    static void Main(string[] args)
    {
        IVehicleFactory twoWheelerfactory = new TwoWheelerFactory();

        IProdctFactory scooter = twoWheelerfactory.GetVehicle("Scooter");
        scooter.Drive(10);

        IProdctFactory bike = twoWheelerfactory.GetVehicle("Bike");
        bike.Drive(20);

        IVehicleFactory fourWheelerFactory = new FourWheelerFactory();
        IProdctFactory car = fourWheelerFactory.GetVehicle("Car");
        car.Drive(100);

        IProdctFactory jeep = fourWheelerFactory.GetVehicle("Car");
        jeep.Drive(200);

        Console.ReadKey();
    }
}

在工厂模式中有两个具体的车辆类(TwoWheelerFactory，FourWheelerFactory)可以吗？

虽然我读了很多关于抽象工厂模式的书，但我仍然不确定它是什么:(有人能帮我把它转换成抽象工厂模式吗？

我读过

Design Patterns: Abstract Factory vs Factory Method

和

http://www.dotnet-tricks.com/Tutorial/designpatterns/FUcV280513-Factory-Method-Design-Pattern---C

Answer 1

来自Wikipedia -抽象工厂模式的本质是“为创建相关或依赖对象族提供一个接口，而不指定它们的具体类。”

关键部分是客户端永远不会知道它有一个汽车或自行车的实例，它只处理抽象类型。

不同的工厂会提供不同的实例，但抽象类型是相同的。

您的自行车，滑板车，吉普和汽车都是具体的产品，应该由工厂的方法来创造。在您的示例中，让这些产品从接口继承，特别是名为“Factory”的接口是错误的，也是令人困惑的(我并不是说接口通常是错误的)。

下面，我简单地将您的示例/措辞(带有一些次要的扩展)应用于Data & Object Factory guys提供的Abstract Factory模式，以帮助您提供一些上下文。

虽然学习新的模式和技术是很棒和令人兴奋的，但不要落入陷阱，试图将你学到的新模式应用到每种情况下。你能做的最好的事情就是编写简单的代码。在实际需要之前，应该避免任何额外的复杂性。

class MainApp
{

    public static void Main()
    {

        // Abstract factory #1
        AbstractFactory factory1 = new EuropeVehicleFactory();
        Client client1 = new Client(factory1);
        client1.Run();

        // Abstract factory #2
        AbstractFactory factory2 = new UsaVehicleFactory();
        Client client2 = new Client(factory2);
        client2.Run();

    }
}

/// <summary>
/// The 'AbstractFactory' abstract class
/// </summary>
abstract class AbstractFactory
{
  public abstract TwoWheelerProduct CreateTwoWheelerProduct();
  public abstract FourWheelerProduct CreateFourWheelerProduct();
}


/// <summary>
/// The 'ConcreteFactory1' class
/// </summary>
class UsaVehicleFactory : AbstractFactory
{
  public override TwoWheelerProduct CreateTwoWheelerProduct()
  {
    return new Bike();
  }
  public override FourWheelerProduct CreateFourWheelerProduct()
  {
    return new Car();
  }
}

/// <summary>
/// The 'ConcreteFactory2' class
/// </summary>
class EuropeVehicleFactory : AbstractFactory
{
  public override TwoWheelerProduct CreateTwoWheelerProduct()
  {
    return new Scooter();
  }
  public override FourWheelerProduct CreateFourWheelerProduct()
  {
    return new Jeep();
  }
}

/// <summary>
/// The 'AbstractProductA' abstract class
/// </summary>
abstract class TwoWheelerProduct
{
}

/// <summary>
/// The 'AbstractProductB' abstract class
/// </summary>
abstract class FourWheelerProduct
{
  //Disclaimer: I am a temporary citizen...
  public abstract void RunOver(TwoWheelerProduct twoWheeler);
}


/// <summary>
/// The 'ProductA1' class
/// </summary>
class Scooter : TwoWheelerProduct
{
}

/// <summary>
/// The 'ProductB1' class
/// </summary>
class Car : FourWheelerProduct
{
  public override void RunOver(TwoWheelerProduct twoWheeler)
  {
    Console.WriteLine(this.GetType().Name +
      " smashes into " + a.GetType().Name);
  }
}

/// <summary>
/// The 'ProductA2' class
/// </summary>
class Bike : TwoWheelerProduct
{
}

/// <summary>
/// The 'ProductB2' class
/// </summary>
class Jeep : FourWheelerProduct
{
  public override void RunsOver(TwoWheelerProduct twoWheeler)
  {
    Console.WriteLine(this.GetType().Name +
      " collides with " + a.GetType().Name);
  }
}

/// <summary>
/// The 'Client' class. Interaction environment for the products.
/// </summary>
class Client
{
  private TwoWheelerProduct _abstractTwoWheeler;
  private FourWheelerProduct _abstractFourWheeler;

  // Constructor
  public Client(AbstractFactory factory)
  {
    _abstractTwoWheeler = factory.CreateTwoWheeler();
    _abstractFourWheeler = factory.CreateFourWheeler();
  }

  public void Run()
  {
    _abstractFourWheeler.RunOver(_abstractTwoWheeler);
  }
}