Builder模式也可以造車。

對于Builder模式來說，首相要把要造的車確定下來：

    public class Car
    {
        public string Model { get; set; }
        public string Engine { get; set; }
        public string Transmission { get; set; }
        public string Body { get; set; }
        public int Doors { get; set; }
        public List<string>  accessories { get; set; }
        public Car()
        {
            Accessories = new List<string>();
        }
        public void ShowCarInfo()
        {
            Console.WriteLine(Model);
            Console.WriteLine(Engine);
            Console.WriteLine(Body);
            Console.WriteLine("門的數量：" + Doors);
            Console.WriteLine(Transmission);
            Console.WriteLine("配置為：");
            foreach (var accessory in Accessories)
            {
                Console.WriteLine("/t{0}", accessory);
            }
        }
    }

這個Car可以交給Builder1也可以交給Builder2，等等，但首先需要提煉出Builder們的一個抽象類。這個抽象Builder可以設置和獲取Car，并提供生產Car各個部件的抽象方法。

   public abstract class CarBuilder
    {
        PRotected Car _car;
        public Car GetCar()
        {
            return _car;
        }
        public void SetCar()
        {
            _car = new Car();
        }
        public abstract void SetModel();
        public abstract void SetEngine();
        public abstract void SetTransmission();
        public abstract void SetBody();
        public abstract void SetDoors();
        public abstract void SetAccessories();
    }

然后，就需要一個具體的Builder來派生抽象Builder。

  public class BuilderOne : CarBuilder
    {
        public override void SetEngine()
        {
            _car.Engine = "發動機1";
        }
        public override void SetModel()
        {
            _car.Model = "型號1";
        }
        public override void SetTransmission()
        {
            _car.Transmission = "變速1";
        }
        public override void SetBody()
        {
            _car.Body = "SUV";
        }
        public override void SetAccessories()
        {
            _car.Accessories.Add("內飾");
            _car.Accessories.Add("外飾");
        }
        public override void SetDoors()
        {
            _car.Doors = 6;
        }
    }   

這個抽象Builder的派生類可能有很多，所以需要一個管理這些派生Builder的類，用來決定到底選用哪個Builder來生產。

   public class BuilderManager
    {
        private readonly CarBuilder _carBuilder;
        public BuilderManager(CarBuilder carBuilder)
        {
            _carBuilder = carBuilder;
        }
        public void BuildCar() 
        {
            _carBuilder.SetCar();
            _carBuilder.SetModel();
            _carBuilder.SetEngine();
            _carBuilder.SetBody();
            _carBuilder.SetDoors();
            _carBuilder.SetTransmission();
            _carBuilder.SetAccessories();
        }
        public Car GetCar()
        {
            return _carBuilder.GetCar();
        }
    }

在客戶端，如果需要造車，就找Builder的管理類，通過它的構造函數傳入具體的Builder。

    class Program
    {
        static void Main(string[] args)
        {
            var builderManager = new BuilderManager(new BuilderOne());
            builderManager.BuildCar();
            var car = builderManager.GetCar();
            car.ShowCarInfo();
            Console.ReadKey();
        }
    }

抽象工廠和Builder模式都可以造車，但兩者有也許的不同：   

● 抽象工廠模式相當于為車找了一個專屬工廠，要求工廠只能造這種類型的車
● Builder模式相當于為車找不同的工廠，不同的工廠生產出來的車型都不一樣