AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

乐在其中设计模式(C#) - 建造者模式(Builder Pattern)

2014-03-09 973
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原文:乐在其中设计模式(C#) - 建造者模式(Builder Pattern)[索引页][源码下载]乐在其中设计模式(C#) - 建造者模式(Builder Pattern) 作者：webabcd 介绍 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
原文: 乐在其中设计模式(C#) - 建造者模式(Builder Pattern)

[索引页]
[源码下载]


乐在其中设计模式(C#) - 建造者模式(Builder Pattern)


作者： webabcd


介绍
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。


示例
用同样的构建过程创建Sql和Xml的Insert()方法和Get()方法。



MessageModel
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// Message实体类
    /// </summary>
    public class MessageModel
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="msg">Message内容</param>
        /// <param name="pt">Message发布时间</param>
        public MessageModel(string msg, DateTime pt)
        {
            this._message = msg;
            this._publishTime = pt;
        }

        private string _message;
        /**//// <summary>
        /// Message内容
        /// </summary>
        public string Message
        {
            get { return _message; }
            set { _message = value; }
        }

        private DateTime _publishTime;
        /**//// <summary>
        /// Message发布时间
        /// </summary>
        public DateTime PublishTime
        {
            get { return _publishTime; }
            set { _publishTime = value; }
        }
    }
}

SqlMessage
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// Sql方式操作Message
    /// </summary>
    public class SqlMessage
    {
        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public List<MessageModel> Get()
        {
            List<MessageModel> l = new List<MessageModel>();
            l.Add(new MessageModel("SQL方式获取Message", DateTime.Now));

            return l;
        }

        /**//// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public bool Insert(MessageModel mm)
        {
            // 代码略
            return true;
        }
    }
}

XmlMessage
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// Xml方式操作Message
    /// </summary>
    public class XmlMessage
    {
        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public List<MessageModel> Get()
        {
            List<MessageModel> l = new List<MessageModel>();
            l.Add(new MessageModel("XML方式获取Message", DateTime.Now));

            return l;
        }

        /**//// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public bool Insert(MessageModel mm)
        {
            // 代码略
            return true;
        }
    }
}

Operation
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 using  System.Reflection;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// 操作（Product）
    /// </summary>
    public class Operation
    {
        private string _type;
        private Dictionary<string, string> _dictionary;

        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="type">产品类型</param>
        public Operation(string type)
        {
            _dictionary = new Dictionary<string, string>();
            this._type = type;
        }

        /**//// <summary>
        /// 索引器
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string this[string key]
        {
            get { return _dictionary[key]; }
            set { _dictionary[key] = value; }
        }

        /**//// <summary>
        /// 获得结果
        /// </summary>
        /// <returns></returns>
        public string GetResult()
        {
            Assembly assembly = Assembly.Load("Pattern.Builder");

            MethodInfo methodGet = assembly.GetType("Pattern.Builder." + _dictionary["get"].Split('|')[0]).GetMethod(_dictionary["get"].Split('|')[1]);
            object objGet = methodGet.Invoke(assembly.CreateInstance("Pattern.Builder." + _dictionary["get"].Split('|')[0]), null);
            List<MessageModel> m = (List<MessageModel>)objGet;
            
            MethodInfo methodInsert = assembly.GetType("Pattern.Builder." + _dictionary["insert"].Split('|')[0]).GetMethod(_dictionary["insert"].Split('|')[1]);
            object objInsert = methodInsert.Invoke(assembly.CreateInstance("Pattern.Builder." + _dictionary["insert"].Split('|')[0]), new object[] { new MessageModel(_dictionary["insert"].Split('|')[2], Convert.ToDateTime(_dictionary["insert"].Split('|')[3])) });
            bool b = (bool)objInsert;

            return "类型为" + this._type + "的执行结果：<br />" + b.ToString() + "<br />" + m[0].Message + " " + m[0].PublishTime.ToString() + "<br />";
        }
    }
}

AbstractMessageBuilder
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// 抽象Message建造者（Builder）
    /// </summary>
    public abstract class AbstractMessageBuilder
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="type">产品类型</param>
        public AbstractMessageBuilder(string type)
        {
            this._operation = new Operation(type);
        }

        /**//// <summary>
        /// 操作（Product）
        /// </summary>
        protected Operation _operation;
        /**//// <summary>
        /// 操作（Product）
        /// </summary>
        public Operation Operation
        {
            get { return _operation; }
            set { _operation = value; }
        }

        /**//// <summary>
        /// 建造插入方法
        /// </summary>
        /// <param name="mm"></param>
        abstract public void BuilderInsert(MessageModel mm);

        /**//// <summary>
        /// 建造获取方法
        /// </summary>
        abstract public void BuilderGet();
    }
}

SqlMessageBuilder
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// SqlMessage建造者（ConcreteBuilder）
    /// </summary>
    public class SqlMessageBuilder : AbstractMessageBuilder
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        public SqlMessageBuilder()
            : base("sql")
        {
 
        }

        /**//// <summary>
        /// 建造Sql插入方法
        /// </summary>
        /// <param name="mm">Message实体对象</param>
        public override void BuilderInsert(MessageModel mm)
        {
            base._operation["insert"] = "SqlMessage|Insert|" + mm.Message + "|" + mm.PublishTime.ToString() + "";
        }

        /**//// <summary>
        /// 建造Sql获取方法
        /// </summary>
        public override void BuilderGet()
        {
            base._operation["get"] = "SqlMessage|Get";
        }
    }
}

XmlMessageBuilder
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// XmlMessage建造者（ConcreteBuilder）
    /// </summary>
    public class XmlMessageBuilder : AbstractMessageBuilder
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        public XmlMessageBuilder()
            : base("xml")
        {
 
        }

        /**//// <summary>
        /// 建造Xml插入方法
        /// </summary>
        /// <param name="mm">Message实体对象</param>
        public override void BuilderInsert(MessageModel mm)
        {
            base._operation["insert"] = "XmlMessage|Insert|"+mm.Message+"|"+mm.PublishTime.ToString()+"";
        }

        /**//// <summary>
        /// 建造Xml获取方法
        /// </summary>
        public override void BuilderGet()
        {
            base._operation["get"] = "XmlMessage|Get";
        }
    }
}

Message
using  System;
 using  System.Collections.Generic;
 using  System.Text;

 namespace  Pattern.Builder
 {
    /**//// <summary>
    /// 指导者（Director）
    /// </summary>
    public class Message
    {
        /**//// <summary>
        /// 调用具体建造者角色以创建产品对象
        /// </summary>
        /// <param name="messageBuilder">AbstractMessageBuilder</param>
        /// <param name="mm">Message实体对象</param>
        public void Construct(AbstractMessageBuilder messageBuilder, MessageModel mm)
        {
            messageBuilder.BuilderInsert(mm);
            messageBuilder.BuilderGet();
        }
    }
}


client
using  System;
 using  System.Data;
 using  System.Configuration;
 using  System.Collections;
 using  System.Web;
 using  System.Web.Security;
 using  System.Web.UI;
 using  System.Web.UI.WebControls;
 using  System.Web.UI.WebControls.WebParts;
 using  System.Web.UI.HtmlControls;

 using  Pattern.Builder;

 public  partial  class  Builder : System.Web.UI.Page
 {
    protected void Page_Load(object sender, EventArgs e)
    {
        Message m = new Message();

        AbstractMessageBuilder amb = new SqlMessageBuilder();
        m.Construct(amb, new MessageModel("插入", DateTime.Now));

        Response.Write(amb.Operation.GetResult());

        amb = new XmlMessageBuilder();
        m.Construct(amb, new MessageModel("插入", DateTime.Now));

        Response.Write(amb.Operation.GetResult());
    }
}

运行结果
类型为sql的执行结果：
True
SQL方式获取Message 2007-5-5 20:53:28
类型为xml的执行结果：
True
XML方式获取Message 2007-5-5 20:53:28


参考
http://www.dofactory.com/Patterns/PatternBuilder.aspx


OK
[源码下载]
文章标签：
C#
SQL
数据格式
XML
索引
设计模式
关键词：
设计模式builder
设计模式建造者模式
设计模式建造者模式builder
设计模式pattern
设计模式builder pattern
杰克.陈
目录
相关文章
flzjkl
|
设计模式 Java Apache
【设计模式】【创建型模式】建造者模式（Builder）
一、入门 什么是建造者模式？ 建造者模式（Builder Pattern）是一种创建型设计模式，用于逐步构建复杂对象。 它通过将对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。 为什么
flzjkl
710 14
杀死一只知更鸟debug
|
设计模式 算法
设计模式--建造者模式 builder
这篇文章通过一个电脑购买的例子，详细解释了建造者模式的四个角色（产品类、抽象构建者、实体构建类和指导者类），并提供了相应的代码实现，阐述了建造者模式在设计复杂对象时的应用和优势。
杀死一只知更鸟debug
296 0
设计模式--建造者模式 builder
游客mh6m5bdpmxyz2
|
设计模式 Java 数据安全/隐私保护
Java 设计模式：装饰者模式（Decorator Pattern）
装饰者模式属于结构型设计模式，允许通过动态包装对象的方式为对象添加新功能，提供比继承更灵活的扩展方式。该模式通过组合替代继承，遵循开闭原则（对扩展开放，对修改关闭）。
游客mh6m5bdpmxyz2
255 1
杀死一只知更鸟debug
|
设计模式
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
这篇文章详细解释了工厂模式，包括简单工厂、工厂方法和抽象工厂三种类型。每种模式都通过代码示例展示了其应用场景和实现方法，并比较了它们之间的差异。简单工厂模式通过一个工厂类来创建各种产品；工厂方法模式通过定义一个创建对象的接口，由子类决定实例化哪个类；抽象工厂模式提供一个创建相关或依赖对象家族的接口，而不需要明确指定具体类。
杀死一只知更鸟debug
1008 0
设计模式-工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）
杀死一只知更鸟debug
|
设计模式 Java
设计模式--适配器模式 Adapter Pattern
这篇文章介绍了适配器模式，包括其基本介绍、工作原理以及类适配器模式、对象适配器模式和接口适配器模式三种实现方式。
杀死一只知更鸟debug
677 1
艾利克斯冰
|
设计模式 算法 Java
Java设计模式-建造者模式（6）
Java设计模式-建造者模式（6）
艾利克斯冰
168 1
大数据文摘
|
设计模式 JavaScript Java
Java设计模式：建造者模式详解
建造者模式是一种创建型设计模式，通过将复杂对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo，帮助读者更好地理解和应用这一模式。
大数据文摘
736 0
热爱技术的小郑
|
设计模式 XML 存储
【四】设计模式~~~创建型模式~~~建造者模式（Java）
文章详细介绍了建造者模式（Builder Pattern），这是一种创建型设计模式，用于将复杂对象的构建与其表示分离，允许分步骤创建一个复杂的对象而无需指定其内部的具体构造细节。通过定义抽象建造者、具体建造者、指挥者和产品角色，建造者模式允许通过相同的构建过程创建不同的产品表示，提高了系统的灵活性和扩展性。
热爱技术的小郑
221 0
蓝易云
|
8月前
|
XML 前端开发 C#
C#编程实践：解析HTML文档并执行元素匹配
通过上述步骤，可以在C#中有效地解析HTML文档并执行元素匹配。HtmlAgilityPack提供了一个强大而灵活的工具集，可以处理各种HTML解析任务。
蓝易云
365 19
长梦
|
C# 开发者
C# 一分钟浅谈：Code Contracts 与契约编程
【10月更文挑战第26天】本文介绍了 C# 中的 Code Contracts，这是一个强大的工具，用于通过契约编程增强代码的健壮性和可维护性。文章从基本概念入手，详细讲解了前置条件、后置条件和对象不变量的使用方法，并通过具体代码示例进行了说明。同时，文章还探讨了常见的问题和易错点，如忘记启用静态检查、过度依赖契约和性能影响，并提供了相应的解决建议。希望读者能通过本文更好地理解和应用 Code Contracts。
长梦
419 3