设计模式のAbstractFactory（虚拟工厂）----创建模式

一、产生背景

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

二、通常做法

在一个产品族里面，定义多个产品。创建工厂的工厂，先产生相应的工厂，再由工厂产生产品。

三、实例

1、构建第一个接口和类

namespace AbstractFactory
{
    public interface IShape
    {
       void draw();
    }
}

    class Circle:IShape
    {
        public void draw()
        {
            Console.WriteLine("Inside Circle::draw() method.");
        }
    }
.
.
.

2、构建第二个接口和类

namespace AbstractFactory
{
    public interface IColor
    {
        void fill();
    }
}

public class Blue:IColor
{
public void fill()
{
Console.WriteLine("fill blue color");
}
}

3、创建工厂

namespace AbstractFactory
{
    public class ColorFactory:AbstractFactory
    {

        public override IShape GetShape(string shapeType)
        {
            return null;
        }

        public override IColor GetColor(string color)
        {
            if (color == null)
            {
                return null;
            }
            if (color.Equals("red"))
            {
                return new Red();
            }
            else if (color.Equals("green"))
            {
                return new Green();
            }
            else if (color.Equals("blue"))
            {
                return new Blue();
            }
            return null;
        }
    }
}

namespace AbstractFactory
{
    public class ShapeFactory:AbstractFactory
    {
        public override IShape GetShape(string shapeType)
        {
            if (shapeType == null)
            {
                return null;
            }
            if (shapeType.Equals("circle"))
            {
                return new Circle();
            }
            else if (shapeType.Equals("rectangle"))
            {
                return new Rectangle();
            }
            else if (shapeType.Equals("square"))
            {
                return new Square();
            }
            return null;
        }

        public override IColor GetColor(string color)
        {
            return null;
        }

    }
}

4、产生工厂的工厂

    public class FactoryProducer
    {
        public static AbstractFactory GetFactory(string choice)
        {
            if (choice.Equals("shape"))
            {
                return new ShapeFactory();
            }
            else if (choice.Equals("color"))
            {
                return new ColorFactory();
            }
            return null;
        }
    }

5、应用

    class Program
    {
        static void Main(string[] args)
        {
            //获取形状工厂
            AbstractFactory shapeFactory = FactoryProducer.GetFactory("shape");

            //获取形状为 Circle 的对象
            IShape shape1 = shapeFactory.GetShape("circle");
            //调用 Circle 的 draw 方法
            shape1.draw();

            //获取形状为 Rectangle 的对象
            IShape shape2 = shapeFactory.GetShape("rectangle");
            //调用 Rectangle 的 draw 方法
            shape2.draw();

            //获取形状为 Square 的对象
            IShape shape3 = shapeFactory.GetShape("square");
            //调用 Square 的 draw 方法
            shape3.draw();

            //获取颜色工厂
            AbstractFactory colorFactory = FactoryProducer.GetFactory("color");

            //获取颜色为 Red 的对象
            IColor color1 = colorFactory.GetColor("red");
            //调用 Red 的 fill 方法
            color1.fill();

            //获取颜色为 Green 的对象
            IColor color2 = colorFactory.GetColor("green");
            //调用 Green 的 fill 方法
            color2.fill();

            //获取颜色为 Blue 的对象
            IColor color3 = colorFactory.GetColor("blue");
            //调用 Blue 的 fill 方法
            color3.fill();

            Console.ReadLine();
        }
    }

四、设计模式分析

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

点击下载源码