我也设计模式——2.Abstract Factory

这个模式是对简单工厂的更高层次上的抽象，UML图如下：

    public abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    public class ConcreteFactory1 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }

        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    public class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }

        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

    public abstract class AbstractProductA { }

    public class ProductA1 : AbstractProductA { }

    public class ProductA2 : AbstractProductA { }


    public abstract class AbstractProductB { }

    public class ProductB1 : AbstractProductB { }

    public class ProductB2 : AbstractProductB { }

于是，在Client端，可以面向接口编程，这么使用：
            AbstractFactory af = new ConcreteFactory1();
            AbstractProductA apa = af.CreateProductA();
            AbstractProductB apb = af.CreateProductB();

抽象工厂，适用于一套产品系列，也就是说，易于增加一个产品——只要同时增加ProductA3，ProductB3，ConcreteFactory3三个类；不易于增加一个方法操作AbstractC——可以使用Decorator模式来完成这个功能。

可以用DB来思考：简单工厂要为每种DB生成一个子类，每个子类都要实现相同的方法——可能会有代码冗余；抽象工厂则是分别抽象出AbstractConnnection和AbstractCommand等基类，注意，容易增加一个OleDBFactory子类以及OleDBConnection和OleDBCommand子类，而不易增加AbstractAdapter基类。