抽象工廠是基於簡單工廠發展而來的，通過抽象工廠，我們可以建立多種型別的工廠，並且依據具體業務需求而在具體工廠裡面進行任意拼裝組合。

介紹

在現實世界中，汽車製作行業有各種各樣的工廠，每個工廠都需要具有生產輪胎、汽車引擎等部件的能力，但是針對具體的工廠，每個部件的生產又各不相同，所有在軟體開發過程中，當我們為客戶端製作各種各樣的面板時，就可以參考這種設計模式。

類圖描述

從上圖我們可以發現，我們通過定義一個抽象工廠 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();
    }
}

總結

當一個產品集合中的多個部件可以任意組合時，使用抽象工廠較為合適，這使得每一層的型別建立較為具體，關注點較為統一。