抽象工厂

　　抽象工厂，即工厂的工厂，该模式属于创建型模式，即创建对象。

　　本例中，将交通工具抽象，分为三大类：航空、火车、汽车。围绕三大类分别对应三个工厂，依次为：AirplaneFactory、TrainFactory、BusFactory，抽象工厂即交通工具为TrafficFactory 。三类交通工具都需要实现自己的交通方式，所以每一类对应一个接口，依次为 IAirplane、ITrain、IBus 。三类交通工具继承抽象交通工具，并实现各自对应的交通方式（飞行、铁轨、高速公路）。其中，每一种交通工具都可以按照自己的类别再一次划分，比如，航空可再划分为东方航空、南方航空等，火车可以划分为高铁、动车等。所以，还需要建立对应的具体交通工具。

具体交通工具：

    public class EasternAir : IAirplane
    {
        public string Fly()
        {
            return "Eastern Air Fly";
        }
    }

    public class SouthernAir : IAirplane
    {
        public string Fly()
        {
            return "SouthernAir Air Fly";
        }
    }

    public class BulletTrains : ITrain
    {
        public string Railroad()
        {
            return "Bullet Trains Railroad";
        }
    }

    public class RailsHigh : ITrain
    {
        public string Railroad()
        {
            return "CRH(China Rails High) Railroad";
        }
    }

交通工具对的交通方式：

    public interface IAirplane
    {
        string Fly();
    }

    public interface ITrain
    {
        string Railroad();
    }

    public interface IBus
    {
    }

交通工具抽象工厂：

    /// <summary>
    /// 抽象工厂类，工厂的工厂
    /// 对交通工具的抽象
    /// </summary>
    public abstract class TrafficFactory
    {
        public abstract IAirplane Airplane(string flightCompany);

        public abstract ITrain Train(string trainType);

        public abstract IBus Bus(string busType);
    }

交通工具工厂：

    /// <summary>
    /// 飞机工厂，继承抽象交通工具类，重写飞机
    /// </summary>
    public class AirplaneFactory : TrafficFactory
    {
        public override IAirplane Airplane(string flightCompany)
        {
            IAirplane airplane = null;
            switch (flightCompany)
            {
                case "ceair":
                    airplane = new EasternAir();
                    break;
                case "csair":
                    airplane = new SouthernAir();
                    break;
                default:
                    break;
            }
            return airplane;
        }

        public override IBus Bus(string busType)
        {
            throw new NotImplementedException();
        }

        public override ITrain Train(string trainType)
        {
            throw new NotImplementedException();
        }
    }

    /// <summary>
    /// 火车工厂，继承抽象交通工具类，重写火车
    /// </summary>
    public class TrainFactory : TrafficFactory
    {
        public override IAirplane Airplane(string flightCompany)
        {
            throw new NotImplementedException();
        }

        public override IBus Bus(string busType)
        {
            throw new NotImplementedException();
        }

        public override ITrain Train(string trainType)
        {
            ITrain train = null;
            switch (trainType)
            {
                case "bullet":
                    train = new BulletTrains();
                    break;
                case "CRH":
                    train = new RailsHigh();
                    break;
                default:
                    break;
            }
            return train;
        }
    }

    /// <summary>
    /// 汽车工厂，继承抽象交通工具类，重写汽车
    /// </summary>
    public class BusFactory : TrafficFactory
    {
        public override IAirplane Airplane(string flightCompany)
        {
            throw new NotImplementedException();
        }

        public override IBus Bus(string busType)
        {
            return null;
        }

        public override ITrain Train(string trainType)
        {
            throw new NotImplementedException();
        }
    }

工厂的工厂：

    public class Factory
    {
        public static TrafficFactory GetTrafficFactory(string trafficType)
        {
            TrafficFactory trafficFactory = null;

            switch (trafficType)
            {
                case "AIRPLANE":
                    trafficFactory = new AirplaneFactory();
                    break;
                case "TRAIN":
                    trafficFactory = new TrainFactory();
                    break;
                case "BUS":
                    trafficFactory = new BusFactory();
                    break;
                default:
                    break;
            }

            return trafficFactory;
        }
    }

客户端：

        static void Main(string[] args)
        {
            //航空
            var airplane = AbstractFactory.Factory.GetTrafficFactory("AIRPLANE");
            //东方航空
            var ceair = airplane.Airplane("ceair");
            Console.WriteLine(ceair.Fly());
            //南方航空
            var csair = airplane.Airplane("csair");
            Console.WriteLine(csair.Fly());

            //火车
            var train = AbstractFactory.Factory.GetTrafficFactory("TRAIN");
            //高铁
            var bullet = train.Train("bullet");
            Console.WriteLine(bullet.Railroad());
            //动车
            var crh = train.Train("CRH");
            Console.WriteLine(crh.Railroad());

            Console.ReadLine();
        }

　　本例中的交通工具分类不够严格，比如航空按照航空公司分类，但火车却没有按照承运段分。