C#设计模式-建造者模式（Builder Pattern）

时间  2020-11-23
标签 算法 设计模式 ide 性能 测试 spa 设计 code 对象 栏目 C# 繁體版
原文   原文链接

引言

在软件测试中，一个项目的自动化测试包括UI自动化、API自动化、压力自动化等，把这些不一样类型的自动化测试组装在一块儿变构成了一个项目的自动化测试。经过执行项目的自动化测试变能执行他的全部类型的自动化测试。固然，在生活中也有相似的，好比电脑，由CPU、磁盘、显卡等部分组成，一辆车由轮胎、车体、发动机等部件构成，客户在买车的时候并不知道该车是如何组装的，他只须要会开这辆车就好了。在设计模式中，咱们将相似的复杂对象的各个部分按照必定的算法组合在一块儿，这种对象的建立工做便称为建造者模式。算法

简介

定义

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象，将复杂的构建与其表示相分离，使得一样的构建过程能够建立不一样的表示。这种类型的设计模式属于建立型模式，它提供了一种建立对象的最佳方式。设计模式

主要解决的问题

在软件系统中，有时候面临一个"复杂对象"的建立工做，其一般由各个部分的子对象用必定算法构成;因为需求的变化，这个复杂对象的各个部分常常面临着剧烈的变化，可是将它们组合到一块儿的算法却相对稳定。如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？
将一个复杂对象的构建与其表示相分离，使得一样的构建过程能够建立不一样的表示。 变与不变分离开。ide

结构图

 

主要角色

  • 抽象建造者角色（Builder）：为建立一个Product对象的各个部件指定抽象接口，以规范产品对象的各个组成成分的建造。通常而言，此角色规定要实现复杂对象的哪些部分的建立，并不涉及具体的对象部件的建立。性能

  • 具体建造者（ConcreteBuilder）

    • 实现Builder的接口以构造和装配该产品的各个部件。即实现抽象建造者角色Builder的方法。测试

    • 定义并明确它所建立的表示，即针对不一样的商业逻辑，具体化复杂对象的各部分的建立。ui

    • 提供一个检索产品的接口。spa

    • 构造一个使用Builder接口的对象即在指导者的调用下建立产品实例。设计

  • 指导者（Director）：调用具体建造者角色以建立产品对象的各个部分。指导者并无涉及具体产品类的信息，真正拥有具体产品的信息是具体建造者对象。它只负责保证对象各部分完整建立或按某种顺序建立。code

  • 产品角色（Product）：建造中的复杂对象。它要包含那些定义组件的类，包括将这些组件装配成产品的接口。对象

具体实现

以一个项目的自动化测试由UI自动化、API自动化、压力自动化组成为例。

产品角色。自动化测试类。

    public sealed class AuToTest
    {

        // 测试用例收集
        private IList<string> allCases = new List<string>();
        
        // 将全部的测试用例集中在一块儿
        public void addCases(string testcases)
        {
            allCases.Add(testcases);
        }
        
        // 进行测试
        public void Test()
        {
            Console.WriteLine("============ 开始执行测试用例 ============");
            foreach (string cases in allCases)
            {
                Console.WriteLine(cases + "执行完毕！");
            }
            Console.WriteLine("============ 执行测试用例结束 ============");
        }
    }

抽象建造者：包含建立产品各个子部件的抽象方法。自动化测试类。

    public abstract class Builder
    {

        // 建立UI自动化测试用例
        public abstract void BuildCasesUI();

        // 建立接口自动化测试用例
        public abstract void BuildCasesAPI();

        // 建立性能自动化测试
        public abstract void BuildCasesStress();

        // 得到组装好的
        public abstract AuToTest GetAuToTest();
    }

具体建造者：实现了抽象建造者接口。以百度自动化测试和华为自动化测试为例。

public class BaiduBuidler : Builder
    {
        AuToTest BaiduAutoTest = new AuToTest();
        public override void BuildCasesUI()
        {
            BaiduAutoTest.addCases("百度 UI 自动化测试");
        }

        public override void BuildCasesAPI()
        {
            BaiduAutoTest.addCases("百度 API 自动化测试");
        }

        public override void BuildCasesStress()
        {
            BaiduAutoTest.addCases("百度 Stress 自动化测试");
        }

        public override AuToTest GetAuToTest()
        {
            return BaiduAutoTest;
        }
    }


    /// 具体建立者，好比华为
    public class HuaWeiBuidler : Builder
    {
        AuToTest HuaWeiAutoTest = new AuToTest();
        public override void BuildCasesUI()
        {
            HuaWeiAutoTest.addCases("华为 UI 自动化测试");
        }

        public override void BuildCasesAPI()
        {
            HuaWeiAutoTest.addCases("华为 API 自动化测试");
        }

        public override void BuildCasesStress()
        {
            HuaWeiAutoTest.addCases("华为 Stress 自动化测试");
        }

        public override AuToTest GetAuToTest()
        {
            return HuaWeiAutoTest;
        }
    }

指挥者：调用建造者中的方法完成复杂对象的建立。将UI自动化、API自动化、压力自动化组建成项目自动化测试。

    public class Director
    {
        // 全部自动化测试组装成一个项目的自动化
        public void Construct(Builder builder)
        {
            builder.BuildCasesUI();
            builder.BuildCasesAPI();
            builder.BuildCasesStress();
        }
    }

客户类。

    class Customer
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder baiduBuilder = new BaiduBuidler();
            Builder huaweiBuidler = new HuaWeiBuidler();

            // 百度项目进行组装
            director.Construct(baiduBuilder);
            // 组装完成后进行执行项目的自动化测试
            AuToTest baiduAutoTest = baiduBuilder.GetAuToTest();
            baiduAutoTest.Test();


            // 华为项目进行自动化测试
            director.Construct(huaweiBuidler);
            AuToTest huaweiAutoTest = huaweiBuidler.GetAuToTest();
            huaweiAutoTest.Test();
        }
    }

完整代码

using System;
using System.Collections.Generic;

namespace 建造者模式
{
    /// <summary>
    /// 客户端
    /// </summary>
    class Customer
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder baiduBuilder = new BaiduBuidler();
            Builder huaweiBuidler = new HuaWeiBuidler();

            // 百度项目进行组装
            director.Construct(baiduBuilder);
            // 组装完成后进行执行项目的自动化测试
            AuToTest baiduAutoTest = baiduBuilder.GetAuToTest();
            baiduAutoTest.Test();


            // 华为项目进行自动化测试
            director.Construct(huaweiBuidler);
            AuToTest huaweiAutoTest = huaweiBuidler.GetAuToTest();
            huaweiAutoTest.Test();
        }
    }



    /// <summary>
    /// 建造者模式中的指挥者
    /// 不一样类型的组装，Construct 方法里面的实现就是建立复杂对象固定算法的实现，是相对稳定的
    /// </summary>
    public class Director
    {
        // 全部自动化测试组装成一个项目的自动化
        public void Construct(Builder builder)
        {
            builder.BuildCasesUI();
            builder.BuildCasesAPI();
            builder.BuildCasesStress();
        }
    }

    
    /// <summary>
    /// 自动化测试类
    /// </summary>
    public sealed class AuToTest
    {

        // 测试用例收集
        private IList<string> allCases = new List<string>();
        
        // 将全部的测试用例集中在一块儿
        public void addCases(string testcases)
        {
            allCases.Add(testcases);
        }
        
        // 进行测试
        public void Test()
        {
            Console.WriteLine("============ 开始执行测试用例 ============");
            foreach (string cases in allCases)
            {
                Console.WriteLine(cases + "执行完毕！");
            }
            Console.WriteLine("============ 执行测试用例结束 ============");
        }
    }


    /// <summary>
    /// 抽象建造者，定义自动化测试时须要那些内容，和最后建立的结果
    /// 在这儿要和组装进行区分，这不是组装的类型
    /// </summary>
    public abstract class Builder
    {

        // 建立UI自动化测试用例
        public abstract void BuildCasesUI();

        // 建立接口自动化测试用例
        public abstract void BuildCasesAPI();

        // 建立性能自动化测试
        public abstract void BuildCasesStress();

        // 得到组装好的
        public abstract AuToTest GetAuToTest();
    }


    /// <summary>
    /// 具体建立者，就是什么项目进行自动化测试，好比百度
    /// </summary>
    public class BaiduBuidler : Builder
    {
        AuToTest BaiduAutoTest = new AuToTest();
        public override void BuildCasesUI()
        {
            BaiduAutoTest.addCases("百度 UI 自动化测试");
        }

        public override void BuildCasesAPI()
        {
            BaiduAutoTest.addCases("百度 API 自动化测试");
        }

        public override void BuildCasesStress()
        {
            BaiduAutoTest.addCases("百度 Stress 自动化测试");
        }

        public override AuToTest GetAuToTest()
        {
            return BaiduAutoTest;
        }
    }


    /// <summary>
    /// 具体建立者，就是什么项目进行自动化测试，好比华为
    /// </summary>
    public class HuaWeiBuidler : Builder
    {
        AuToTest HuaWeiAutoTest = new AuToTest();
        public override void BuildCasesUI()
        {
            HuaWeiAutoTest.addCases("华为 UI 自动化测试");
        }

        public override void BuildCasesAPI()
        {
            HuaWeiAutoTest.addCases("华为 API 自动化测试");
        }

        public override void BuildCasesStress()
        {
            HuaWeiAutoTest.addCases("华为 Stress 自动化测试");
        }

        public override AuToTest GetAuToTest()
        {
            return HuaWeiAutoTest;
        }
    }


}

执行结果

============ 开始执行测试用例 ============
百度 UI 自动化测试执行完毕！
百度 API 自动化测试执行完毕！
百度 Stress 自动化测试执行完毕！
============ 执行测试用例结束 ============
============ 开始执行测试用例 ============
华为 UI 自动化测试执行完毕！
华为 API 自动化测试执行完毕！
华为 Stress 自动化测试执行完毕！
============ 执行测试用例结束 ============

适用场景

  • 当建立复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
  • 相同的方法，不一样的执行顺序，产生不一样的事件结果时。
  • 多个部件或零件,均可以装配到一个对象中，可是产生的运行结果又不相同时。
  • 产品类很是复杂，或者产品类中的调用顺序不一样产生了不一样的效能。
  • 建立一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，可是对象的内部组成构件面临着复杂的变化。

优缺点

优势：

  • 封装性好，构建和表示分离。
  • 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
  • 客户端没必要知道产品内部组成的细节，建造者能够对建立过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

缺点：

  • 产品的组成部分必须相同，这限制了其使用范围。
  • 若是产品的内部变化复杂，若是产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

与工厂模式区别

  • 建造者模式更加注重方法的调用顺序，工厂模式注重建立对象。
  • 建立对象的力度不一样，建造者模式建立复杂的对象，由各类复杂的部件组成，工厂模式建立出来的对象都同样
  • 关注重点不同，工厂模式只须要把对象建立出来就能够了，而建造者模式不只要建立出对象，还要知道对象由哪些部件组成。
  • 建造者模式根据建造过程当中的顺序不同，最终对象部件组成也不同。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程