乐在其中设计模式(C#) - 装饰模式(Decorator Pattern)

原文:乐在其中设计模式(C#) - 装饰模式(Decorator Pattern)
[索引页][源码下载]

乐在其中设计模式(C#) - 装饰模式(Decorator Pattern)

作者：webabcd

介绍
动态地给一个对象添加一些额外的职责。就扩展功能而言，它比生成子类方式更为灵活。

示例
有一个Message实体类，某个对象对它的操作有Insert()和Get()方法，现在扩展这个对象的功能。

MessageModel

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

namespace Pattern.Decorator
{
    /**//// <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; }
        }
    }
}

AbstractMessage

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

namespace Pattern.Decorator
{
    /**//// <summary>
    /// 操作Message的抽象构件（Component）
    /// </summary>
    public abstract class AbstractMessage
    {
        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public abstract List<MessageModel> Get();

        /**//// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public abstract bool Insert(MessageModel mm);
    }
}

SqlMessage

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

namespace Pattern.Decorator
{
    /**//// <summary>
    /// Sql方式操作Message（ConcreteComponent）
    /// </summary>
    public class SqlMessage : AbstractMessage
    {
        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public override 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 override bool Insert(MessageModel mm)
        {
            // 代码略
            return true;
        }
    }
}

XmlMessage

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

namespace Pattern.Decorator
{
    /**//// <summary>
    /// Xml方式操作Message（ConcreteComponent）
    /// </summary>
    public class XmlMessage : AbstractMessage
    {
        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public override 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 override bool Insert(MessageModel mm)
        {
            // 代码略
            return true;
        }
    }
}

AbstractMessageWrapper

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

namespace Pattern.Decorator
{
    /**//// <summary>
    /// 装饰AbstractMessage（Decorator）
    /// </summary>
    public abstract class AbstractMessageWrapper : AbstractMessage
    {
        private AbstractMessage _abstractMessage;

        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="abstractMessage">AbstractMessage</param>
        public AbstractMessageWrapper(AbstractMessage abstractMessage)
        {
            this._abstractMessage = abstractMessage;
        }

        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public override List<MessageModel> Get()
        {
            return _abstractMessage.Get();
        }

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

CheckUserWrapper

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

namespace Pattern.Decorator
{
    /**//// <summary>
    /// 扩展出用户验证的功能（ConcreteDecorator）
    /// </summary>
    public class CheckUserWrapper : AbstractMessageWrapper
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="abstractMessage">AbstractMessage</param>
        public CheckUserWrapper(AbstractMessage abstractMessage)
            : base(abstractMessage)
        {
            
        }

        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public override List<MessageModel> Get()
        {
            List<MessageModel> l = base.Get();

            foreach (MessageModel mm in l)
            {
                mm.Message += "（经过用户验证）";
            }

            return l;
        }

        /**//// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public override bool Insert(MessageModel mm)
        {
            // 在这里扩展功能

            return base.Insert(mm);
        }

    }
}

CheckInputWrapper

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

namespace Pattern.Decorator
{
    /**//// <summary>
    /// 扩展出输入验证的功能（ConcreteDecorator）
    /// </summary>
    public class CheckInputWrapper : AbstractMessageWrapper
    {
        /**//// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="abstractMessage">AbstractMessage</param>
        public CheckInputWrapper(AbstractMessage abstractMessage)
            : base(abstractMessage)
        {
            
        }

        /**//// <summary>
        /// 获取Message
        /// </summary>
        /// <returns></returns>
        public override List<MessageModel> Get()
        {
            List<MessageModel> l = base.Get();

            foreach (MessageModel mm in l)
            {
                mm.Message += "（经过输入验证）";
            }

            return l;
        }

        /**//// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="mm">Message实体对象</param>
        /// <returns></returns>
        public override bool Insert(MessageModel mm)
        {
            // 在这里扩展功能

            return base.Insert(mm);
        }
    }
}

Test

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.Decorator;

public partial class Decorator : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        AbstractMessage message = new SqlMessage();

        AbstractMessageWrapper amr = new CheckUserWrapper(message);

        Response.Write(amr.Get()[0].Message + " " + amr.Get()[0].PublishTime.ToString());
        Response.Write("<br />");

        AbstractMessageWrapper amr2 = new CheckInputWrapper(message);

        Response.Write(amr2.Get()[0].Message + " " + amr2.Get()[0].PublishTime.ToString());
        Response.Write("<br />");

        AbstractMessageWrapper amr3 = new CheckUserWrapper(message);
        AbstractMessageWrapper amr4 = new CheckInputWrapper(amr3);

        Response.Write(amr4.Get()[0].Message + " " + amr4.Get()[0].PublishTime.ToString());
        Response.Write("<br />");
    }
}

运行结果
SQL方式获取Message（经过用户验证） 2007-5-13 19:34:01
SQL方式获取Message（经过输入验证） 2007-5-13 19:34:01
SQL方式获取Message（经过用户验证）（经过输入验证） 2007-5-13 19:34:01

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

OK
[源码下载]

时间： 2024-02-22 16:50:09

乐在其中设计模式(C#) - 装饰模式(Decorator Pattern)的相关文章

乐在其中设计模式(C#) - 观察者模式(Observer Pattern)

原文:乐在其中设计模式(C#) - 观察者模式(Observer Pattern)[索引页][源码下载] 乐在其中设计模式(C#) - 观察者模式(Observer Pattern) 作者:webabcd 介绍 定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新. 示例 有一个Message实体类,某些对象对它的操作有Insert()方法,当发生某些改变的时候,通知所有这些对象并执行Insert()方法. MessageModel using

乐在其中设计模式(C#) - 适配器模式(Adapter Pattern)

原文:乐在其中设计模式(C#) - 适配器模式(Adapter Pattern)[索引页][源码下载] 乐在其中设计模式(C#) - 适配器模式(Adapter Pattern) 作者:webabcd 介绍 将一个类的接口转换成客户希望的另外一个接口.Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作. 示例 有一个Message实体类,某个类对它的操作有Insert()和Get()方法.现在需要把这个类转到另一个接口,分别对应Add()和Select()方法. Mess

【设计模式】—— 装饰模式Decorator

模式意图 在不改变原来类的情况下,进行扩展. 动态的给对象增加一个业务功能,就功能来说,比生成子类更方便. 应用场景 1 在不生成子类的情况下,为对象动态的添加某些操作. 2 处理一些可以撤销的职责. 3 当不能使用生成子类来扩充时. 模式结构 Component 外部接口,用于定义外部调用的形式.提供默认的处理方法. interface Component{ public void operation(); }   ConcreteComponent  具体的处理类,用于实现operation

C++ 设计模式 装饰模式(Decorator Pattern)

C++ 设计模式 装饰模式 在结构型模式中装饰模式给我留下了深刻的印象,其中也感觉到在设计模式中基本都是 依赖C++的多态来实现,装饰模式也不例外,他允许在不改变原有类的代码的基础上, 不通过直接继承原有类的代码通过一个抽象接口层进行实现,甚至可以随意的组合, 所以这里记录之以备使用 下面是模型图: 下面是一个简单的模拟代码,模拟本来一个工具只有写功能,但是我们要不断的扩充其 功能让它有听有读的功能: 这是跑出来的结果 ----source tool---- i can write!! ----

解读设计模式----装饰模式(Decorator Pattern)

装饰模式(Decorator)也叫包装器模式(Wrapper).以"装饰"的含义生动形象地描绘了"动态地给一个对象添加一些额外的职责"的意图.GOF在<设计模式>一书中给出的定义为:动态地给一个对象添加一些额外的职责.装饰模式充分利用了继承和聚合的优势,创造出无与论比的设计美学.就增加功能来说,Decorator模式相比生成子类更为灵活. UML图: 一.使用Decorator模式的动机 现在有这样一个场景,要求我们为一个对象动态添加新的职责,这个职责并

温故而知新:设计模式之装饰模式(Decorator)

小时候对日本的动画片十分着迷,"圣斗士"是我的最爱:长大后也曾经一度对"海贼王"十分痴迷:大学看武侠小说时,也特别喜欢那种主人公有奇遇的情况:吃到一颗千年异果,然后功夫大增60年... 这些个场景都有一个共同点:对象(或系统)会因为一些需求(通常这些需求之间没有任何关联),而扩展自己的功能.具体来说:青铜战士如果有幸能穿上黄金圣衣,不管你是不是黄金圣斗士,在穿上黄金圣衣的那一刻,你就具有黄金圣斗士的能力:海赋王中的人物,如果能吃到一颗奇异果,就能获得特别的能力(比如

详解java装饰模式（Decorator Pattern）_java

一.装饰器模式(Decorator Pattern) 允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装. 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能. 我们通过下面的实例来演示装饰器模式的使用.其中,我们将把一个形状装饰上不同的颜色,同时又不改变形状类. 二.实现我们将创建一个 Shape 接口和实现了 Shape 接口的实体类.然后我们创建一个实现了 Shape 接口的抽象装饰

java 装饰模式（Decorator Pattern）详解_java

装饰器模式(Decorator Pattern)允许向一个现有的对象添加新的功能,同时又不改变其结构.这种类型的设计模式属于结构型模式,它是作为现有的类的一个包装. 这种模式创建了一个装饰类,用来包装原有的类,并在保持类方法签名完整性的前提下,提供了额外的功能. 我们通过下面的实例来演示装饰器模式的使用.其中,我们将把一个形状装饰上不同的颜色,同时又不改变形状类. 实现 我们将创建一个 Shape 接口和实现了 Shape 接口的实体类.然后我们创建一个实现了 Shape 接口的抽象装饰类Sha

.NET设计模式-装饰模式（Decorator Pattern）

装饰模式(Decorator Pattern) --.NET设计模式系列之十 Terrylee,2006年3月 概述 在软件系统中,有时候我们会使用继承来扩展对象的功能,但是由于继承为类型引入的静态特质,使得这种扩展方式缺乏灵活性:并且随着子类的增多(扩展功能的增多),各种子类的组合(扩展功能的组合)会导致更多子类的膨胀.如何使"对象功能的扩展"能够根据需要来动态地实现?同时避免"扩展功能的增多"带来的子类膨胀问题?从而使得任何"功能扩展变化"所