class Program
    {
        /// <summary>
        /// 小轿车类
        /// </summary>
        public sealed class SaloonCar
        {
            //小轿车部件集合
            private IList<string> parts = new List<string>();

            //把单个部件添加到小轿车部件集合中
            public void Add(string part)
            {
                parts.Add(part);
            }

            public void Show()
            {
                Console.WriteLine("小轿车开始组装.......");
                foreach (string part in parts)
                {
                    Console.WriteLine("部件[" + part + "]已组装。");
                }

                Console.WriteLine("小轿车组装完毕。");
            }
        }

        /// <summary>
        /// 抽象建造者，它定义了要创建什么部件和最后创建的结果，但是不是组装的的类型，切记。
        /// </summary>
        public abstract class Builder
        {
            //创建车门
            public abstract void BuildSaloonCarDoor();
            //创建车轮
            public abstract void BuildSaloonCarWheel();
            //创建车引擎
            public abstract void BuildSaloonCarEngine();
            //获得组装好的小轿车
            public abstract SaloonCar GetSaloonCar();
        }

        /// <summary>
        /// 具体创建者，具体车型的创建者，例如：别克。
        /// </summary>
        public sealed class BuickBuilder : Builder
        {
            SaloonCar buickCar = new SaloonCar();
            public override void BuildSaloonCarDoor()
            {
                buickCar.Add("Buick's door");
            }

            public override void BuildSaloonCarWheel()
            {
                buickCar.Add("Buick's wheel");
            }

            public override void BuildSaloonCarEngine()
            {
                buickCar.Add("Buick's engine");
            }

            public override SaloonCar GetSaloonCar()
            {
                return buickCar;
            }
        }

        /// <summary>
        /// 具体创建者，具体车型的创建者，例如：奥迪
        /// </summary>
        public sealed class AoDiBuilder : Builder
        {
            SaloonCar aoDiCar = new SaloonCar();
            public override void BuildSaloonCarDoor()
            {
                aoDiCar.Add("Aodi's door");
            }

            public override void BuildSaloonCarWheel()
            {
                aoDiCar.Add("Aodi's wheel");
            }

            public override void BuildSaloonCarEngine()
            {
                aoDiCar.Add("Aodi's engine");
            }

            public override SaloonCar GetSaloonCar()
            {
                return aoDiCar;
            }
        }

        /// <summary>
        /// 这个类型才是组装的
        /// Construct方法里面的实现就是创建复杂对象固定算法的实现，该算法是固定的或者说是相对稳定的。
        /// 这个人当然就是老板了，也就是建造者模式中的指挥者。
        /// </summary>
        public class Director
        {
            //组装汽车
            public void Construct(Builder builder)
            {
                builder.BuildSaloonCarDoor();
                builder.BuildSaloonCarWheel();
                builder.BuildSaloonCarEngine();
            }
        }

        static void Main(string[] args)
        {
            #region 建造者模式
            Director director = new Director();
            Builder buickBuilder = new BuickBuilder();
            Builder aoDiBuilder = new AoDiBuilder();

            //组装别克小轿车
            director.Construct(buickBuilder);
            SaloonCar buickCar = buickBuilder.GetSaloonCar();
            buickCar.Show();

            Console.WriteLine();

            //组装奥迪小轿车
            director.Construct(aoDiBuilder);
            SaloonCar aoDiCar = aoDiBuilder.GetSaloonCar();
            aoDiCar.Show();

            Console.Read();
            #endregion
        }
    }