c#复习 设计模式--建造者模式

设计模式之建造者模式

1. 模式含义：
   将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
2. 适用场景：
   1. 需要创建的对象比较复杂，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。
   2. 要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。
3. 模式角色：
   Product(产品类)：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂。
   Builder(抽象建造者)：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
   ConcreteBuilder(建造者)：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品，返回组建好的产品。
   Director(导演类)：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类，一般来说，导演类被用来封装程序中易变的部分。
4. 代码实现
   产品类

/// <summary>
    /// 一个较为复杂的对象，
    /// 此例中是给女儿买衣服--充当产品类
    /// </summary>
   public class Clothes
    {
        List<string> _clothes = new List<string>();
        public void MyClothes(string clothes)
        {
            _clothes.Add(clothes);
        }
        public void ShowClothes()
        {
            int idx = 1;
            Console.WriteLine("请看我的一套漂亮衣服：");
            foreach (string item in _clothes)
            {
                Console.WriteLine($"我的第{idx}件衣服：{item}");
                idx++;
            }
            Console.WriteLine("我的衣服展示完毕\n");
        }
    }

Builder类

    /// <summary>
    /// 引入抽象建造者的目的，是为了将建造者的具体过程交与它的子类来实现，一般至少会有两个抽象方法
    /// 一个用来建造产品，一个用来返回产品。
    /// </summary>
   public abstract class Builder
    {
        public abstract void BuildPants();
        public abstract void BuildJacket();
        public abstract void BuildHat();
        public abstract Clothes GetClothes();
    }

具体实现类

    /// <summary>
    /// 建造者类，实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品，返回组建好的产品
    /// </summary>
    class ConcreteClothes_Blue :Builder
    {
        readonly Clothes _Clothes = new Clothes();
        public override void BuildHat()
        {
            _Clothes.MyClothes("Blue Hat");
        }
        public override void BuildJacket()
        {
            _Clothes.MyClothes("Blue Jacket");
        }
        public override void BuildPants()
        {
            _Clothes.MyClothes("Blue Pants");
        }
        public override Clothes GetClothes()
        {
            return _Clothes;
        }
    }
    //第二个具体实现类
    /// <summary>
    /// 建造者类，实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品，返回组建好的产品
    /// </summary>
    class ConcreteClothes_Red:Builder
    {
        readonly Clothes redClothes = new Clothes();
        public override void BuildHat()
        {
            redClothes.MyClothes("Red Hat");
        }
        public override void BuildJacket()
        {
            redClothes.MyClothes("Red Jacket");
        }
        public override void BuildPants()
        {
            redClothes.MyClothes("Red Pants");
        }
        public override Clothes GetClothes()
        {
            return redClothes;
        }
    }

Director类

    /// <summary>
    ///导演类，负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，而是与builder类直接交互。
    ///一般来说，导演类负责封装程序中易变的部分
    /// 导演类，负责衣服的采购-此例中为妈妈类 
    /// </summary>
    public class Mom
    {
        /// <summary>
        /// 妈妈挑选衣服
        /// </summary>
        /// <param name="builder"></param>
        public void Construct(Builder builder)
        {
            builder.BuildHat();
            builder.BuildJacket();
            builder.BuildPants();
        }
    }

客户端类

class Program
    {
        static void Main(string[] args)
        {
            //妈妈找到服装店的老板Builder，需要买衣服个女儿
            Mom mom = new Mom();
            //老板builder告诉两个店员，开始挑选衣服。
            Builder b1 = new ConcreteClothes_Blue();
            Builder b2 = new ConcreteClothes_Red();

            mom.Construct(b1);
            mom.Construct(b2);

            //衣服买到了
            Clothes clothesBlue = b1.GetClothes();
            Clothes clothesRed = b2.GetClothes();

            //展示衣服
            clothesBlue.ShowClothes();
            clothesRed.ShowClothes();

            Console.ReadLine();
        }
    }

运行结果

完毕。