设计模式系列- 抽象工厂模式

抽象工厂是基于简单工厂发展而来的，通过抽象工厂，我们可以创建多种类型的工厂，并且依据具体业务需求而在具体工厂里面进行任意拼装组合。

介绍

在现实世界中，汽车制作行业有各种各样的工厂，每个工厂都需要具有生产轮胎、汽车引擎等部件的能力，但是针对具体的工厂，每个部件的生产又各不相同，所有在软件开发过程中，当我们为客户端制作各种各样的皮肤时，就可以参考这种设计模式。

类图描述

从上图我们可以发现，我们通过定义一个抽象工厂 abstractfactory 来约束具体每种工厂所具备的能力，然后通过定义 ishape 和 icolor 来约束具体每个部件所具备的行为。接着，对相应接口进行继承并实现相应行为从而达到能生产具体某种类型的对象。最后，上层公共调用工厂管理类来获取具体的产品对象，而对其内部构成不用关心。

代码实现

1、定义部件接口

public interface icolor
{
    void fill();
}

public interface ishape
{
    void draw();
}

2、定义各种类型的部件元素

public class blue:icolor
{
    public void fill()
    {
        console.writeline("filled with blue");
    }
}

public class green : icolor
{
    public void fill()
    {
        console.writeline("filled with green");
    }
}

class red:icolor
{
    public void fill()
    {
        console.writeline("filled with red");
    }
}

public class circle:ishape
{
    public void draw()
    {
        console.writeline("i am a circle");
    }
}

public class rectangle:ishape
{
    public void draw()
    {
        console.writeline("i am a rectangle");
    }
}

public class square : ishape
{
    public void draw()
    {
        console.writeline("i am a square");
    }
}

3、定义抽象工厂

public abstract class abstractfactory
{
    public abstract icolor getcolor(colortype colortype);

    public abstract ishape getshape(shapetype shapetype);
}

3、定义具体工厂

public class colorfactory:abstractfactory
{
    public override icolor getcolor(colortype colortype)
    {
        icolor color = null;
        switch (colortype)
        {
            case colortype.blue:
                color= new blue();
                break;
            case colortype.green:
                color =new green();
                break;
            case colortype.red:
                color = new red();
                break;
            default:
                throw new argumentoutofrangeexception(nameof(colortype), colortype, null);
        }

        return color;
    }

    public override ishape getshape(shapetype shapetype)
    {
        return null;
    }
}

public class shapefactory:abstractfactory
{
    public override icolor getcolor(colortype colortype)
    {
        return null;
    }

    public override ishape getshape(shapetype shapetype)
    {
        ishape shape = null;
        switch (shapetype)
        {
            case shapetype.circle:
                shape = new circle();
                break;
            case shapetype.rectangle:
                shape = new rectangle();
                break;
            case shapetype.square:
                shape = new square();
                break;
            default:
                throw new argumentoutofrangeexception(nameof(shapetype), shapetype, null);
        }
        return shape;
    }
}

4、定义工厂管理类

public class factoryproducer
{
    public static factories.abstractfactory getfactory(producertype producertype)
    {
        switch (producertype)
        {
            case producertype.shape:
                return new shapefactory();
            case producertype.color:
                return new colorfactory();
            default:
                throw new argumentoutofrangeexception(nameof(producertype), producertype, null);
        }
    }
}

5、上层调用

class program
{
    static void main(string[] args)
    {
        factories.abstractfactory shapefactory = factoryproducer.getfactory(producertype.shape);
        ishape shape = shapefactory.getshape(shapetype.circle);
        shape.draw();

        factories.abstractfactory colorfactory = factoryproducer.getfactory(producertype.color);
        icolor color = colorfactory.getcolor(colortype.red);
        color.fill();

        console.readkey();
    }
}

总结

当一个产品集合中的多个部件可以任意组合时，使用抽象工厂较为合适，这使得每一层的类型创建较为具体，关注点较为统一。