设计模式 抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据里氏替换原则，任何接受父类型的地方，都应当能够接受子类型。

抽象工厂模式结构图：

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。

应用场景：一个生产集团，在北京的工厂需要生产A类汽车，A类电视；在上海的工厂需要生产B类汽车，A类电视。而在广州的工厂需要生产C类汽车，C类电视。我们可以使用抽象工厂，抽象出工厂类，和产品类，然后继承工厂类，生产所需要的具体产品类型，产品继承抽象出来的产品，实现里面的行为方法。

1.抽象出Car产品和TV产品

    /// <summary>
    /// 抽象汽车产品
    /// </summary>
    public abstract class Car
    {
        public abstract void Build();
    }

    /// <summary>
    /// 抽象TV产品
    /// </summary>
    public abstract class TV
    {
        public abstract void work();
    }

2.继承自抽象出来的产品类，实现里面的方法，成为具体产品：这里只举例Acar和TVA的，后面的Bcar,Ccar，TVB,TVC,类似。

    public class CarA:Car    
    {
        public override void Build()
        {
            Console.WriteLine("CarA");
        }
    }

    public class TVA : TV
    {
        public override void work()
        {
            Console.WriteLine("TVA");
        }
    }

3.抽象出工厂类，里面有待实现创建产品的方法

    /// <summary>
    /// 抽象生产工厂
    /// </summary>
    public abstract class AbstractFactory
    {

        /// <summary>
        /// 生产TV产品
        /// </summary>
        /// <returns></returns>
        public abstract TV newTV();

        /// <summary>
        /// 生产Car类产品
        /// </summary>
        /// <returns></returns>
        public abstract Car newCar();
    }

4.创建具体的工厂类，继承自抽象出来的工厂，实现里面创建具体产品的方法。例：后面的B工厂，和C工厂类似实现

    /// <summary>
    /// A工厂
    /// </summary>
    public class AbstractFactoryA:AbstractFactory
    {
        /// <summary>
        /// 生产A品牌电视
        /// </summary>
        /// <returns></returns>
        public override TV newTV()
        {
            return new TVA();
        }

        /// <summary>
        /// 生产A品牌汽车
        /// </summary>
        /// <returns></returns>
        public override Car newCar()
        {
            return new CarA();  
        } 
    }

    /// <summary>
    /// B工厂生
    /// </summary>
    public class AbstractFactoryB:AbstractFactory
    {
        /// <summary>
        /// 生产B品牌电视
        /// </summary>
        /// <returns></returns>
        public override TV newTV()
        {
            return new TVB();
        }

        /// <summary>
        /// 生产A品牌汽车
        /// </summary>
        /// <returns></returns>
        public override Car newCar()
        {
            return new CarA();
        }
    }

    public class AbstractFactoryC:AbstractFactory
    {
        /// <summary>
        /// 生产C品牌电视
        /// </summary>
        /// <returns></returns>
        public override TV newTV()
        {
            return new TVC();
        }

        /// <summary>
        /// 生产C品牌汽车
        /// </summary>
        /// <returns></returns>
        public override Car newCar()
        {
            return new CarC();
        }
    }

5.调用，根据具体情况进行选择，现在是在哪一个工厂，就创建该工厂

    class Program  
    {  
        static void Main(string[] args)  
        {  
            AbstractFactory factorysubA = new AbstractFactoryA();  
            TV t = factorysubA.newTV();  
            Car c = factorysubA.newCar();  
            Console.WriteLine("A工厂生产：");  
            t.work();  
            c.Build();  
  
            AbstractFactory factorysubB = new AbstractFactoryB();  
            t = factorysubB.newTV();  
            c = factorysubB.newCar();  
            Console.WriteLine("B工厂生产：");  
            t.work();  
            c.Build();  
  
            AbstractFactory factorysunC = new AbstractFactoryC();  
            t = factorysunC.newTV();  
            c = factorysunC.newCar();  
            Console.WriteLine("C工厂生产：");  
            t.work();  
            c.Build();  
            Console.Read();  
        }  
    }