重看Decorator Pattern，联想到Delegate传递及Flags Enum--欢迎拍砖！

　　话说装饰模式（Decorator）的动机是“动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。[GOF 《设计模式》]”。再次学到该模式，有感，联想到Delegate和Flags Enum。Delegate也可实现在已有功能上动态添加新功能，有点”装饰“的意图，Flags Enum可以进行组合使用。如果对装饰模式不熟悉，请移步大神博文http://terrylee.cnblogs.com/archive/2006/03/01/340592.html。本文描述该模式的相关思考，不正之处，请大神指点拍砖！谢谢

　　该模式的UML图：

　，Decorator抽象，既继承Component又组合引用Component，为什么需要这样呢？从该模式的具体代码看到，装饰之上可以继续装饰，故需要引用一个装饰，为什么有需要继承呢，感觉装饰需要一个抽象吧。

　　现在来假设一个场景，有一个现有的对象，如下：

public class Component
{
public void Operation(string msg)
{
Console.WriteLine("Compent.Operation。hi，:"+msg);
}
}

该操作不是可override的，那怎么使用装饰模式来扩展新功能呢？这里给出装饰模式的“变形代码”

public class ComponentWrapper
{
public virtual void Operation(string msg)
{
Component m_Component = new Component();
m_Component.Operation(msg);
}
}

public class ComponentWrapper1 : ComponentWrapper
{
private ComponentWrapper m_decorator;
public ComponentWrapper1(ComponentWrapper decorator)
{
m_decorator = decorator;
}
public override void Operation(string msg)
{
m_decorator.Operation(msg);
Add(msg);
}
public static void Add(string msg)
{
Console.WriteLine("ComponentWrapper1 added");
}
}

public class ComponentWrapper2 : ComponentWrapper
{
private ComponentWrapper m_decorator;
public ComponentWrapper2(ComponentWrapper decorator)
{
m_decorator = decorator;
}
public override void Operation(string msg)
{
m_decorator.Operation(msg);
Add(msg);
}
public static void Add(string msg)
{
Console.WriteLine("ComponentWrapper2 added");
}
}

//调用代码
ComponentWrapper d = new ComponentWrapper();//未装饰
ComponentWrapper d1 = new ComponentWrapper1(d);//装饰上功能1
ComponentWrapper d2 = new ComponentWrapper2(d1);//装饰上功能2

d2.Operation("stevey");

上面代码中，ComponentWrapper 作为装饰的基类，对已有功能进行包装，在装饰1中继承装饰基类又包含一个装饰。可能说包装感觉更形象一点，一层一层的包装，或者说人穿的衣服也是一层一层的，哈哈。可以看到，一个装饰对象就作为一个”功能集“整体，实际上是一个引用装饰链，调用依次传递到顶端。由此联想到，功能也可以追加，功能也可以做成像链式依次执传递。遵循上面场景的方法契约，于是就凭着感觉写出如下code：

public static class ComponentExtension
{
/// <summary>
/// 在已有操作之后加上新操作
/// </summary>
/// <param name="action">原操作</param>
/// <param name="otherAction">新操作</param>
/// <returns></returns>
public static Action<string> After(this Action<string> action,Action<string> otherAction)
{
return (msg) => {
action(msg);
otherAction(msg);
};
}

public static Action<string> Before(this Action<string> action, Action<string> otherAction)
{
return (msg) =>
{
otherAction(msg);
action(msg);
};
}
}

调用代码：

//使用delegate装饰新功能
Action<string> action = new Component().Operation;
Action<string> wrapper1 = action.After(ComponentWrapper1.Add);//装饰上功能1
Action<string> wrapper2 = wrapper1.After((msg) =>//装饰上功能2
{
Console.WriteLine("wrapper2 added");
});
wrapper2("hello");
Console.WriteLine("*****************************");
//
Action<string> wrapper3 = wrapper1.After(wrapper2);
wrapper3("（原功能+功能1）+{（原功能+功能1）+装饰上功能2}");//在已有的装饰整体上加上另一个装饰

上面的代码可以链式，其他不解释了，代码是最直接的意思表达，在一个功能上继续包装一个功能，得到的就是一个装饰，可以作为整体，继续装饰。。。貌似比模式轻量级点不。

　　标记枚举，也有点”装饰“的味道，MSDN上的代码：

[Flags]
enum Days2
{
None = 0x0,
Sunday = 0x1,
Monday = 0x2,
Tuesday = 0x4,
Wednesday = 0x8,
Thursday = 0x10,
Friday = 0x20,
Saturday = 0x40
}
//Flags Enum
// Initialize with two flags using bitwise OR.
var meetingDays = Days2.Tuesday | Days2.Thursday;

// Set an additional flag using bitwise OR.
meetingDays = meetingDays | Days2.Friday;

Console.WriteLine("Meeting days are {0}", meetingDays);
// Output: Meeting days are Tuesday, Thursday, Friday

// Remove a flag using bitwise XOR.
meetingDays = meetingDays ^ Days2.Tuesday;
Console.WriteLine("Meeting days are {0}", meetingDays);
// Output: Meeting days are Thursday, Friday

　　就写到这里吧，感觉有点语无伦次，不在状态，大家就将就看吧。算是一点装饰模式的读后感，欢迎大家讨论，不正之处，还请指出，谢谢！