设计模式：装饰者模式

　　设计模式系列目录

　　装饰者模式么，在生活中我们是经常接触的。比如像我们这么快节奏的生活，好多都是早上去买煎饼。一般我们会这么说：“来一个粗粮煎饼，加两个鸡蛋，加一根肠”

或者：“来个山东煎饼，只加土豆丝”等等。“煎饼” 就是这个么个有弹性的对象，面饼是不变的，其它的像鸡蛋，肠什么的者在装饰面饼。这个也是我们编程时的一个设计原则

对扩展开放，对修改关闭。（在最后我会给出C# 和C++ 两种代码示例）

　　装饰者模式和“煎饼”差不多，它可以动态地将责任("鸡蛋“、“肠”...)附加到对象(”煎饼“)上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

　　我们看一下装饰者模式的类图：

看这个类图我们可以总结一下装饰者模式的特点：

1.被装饰对象和装饰品有相同的接口。这样装饰品和被装饰对象就可以相互交互。

2.装饰品对象包含一个被装饰对象的引用。

让我们做一个煎饼吧：

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

namespace DecoratorDemo
{
    [Flags]
    public enum BcType
    {
        None = 0,       // 0
        SdCakeType,     // 山东煎饼
        EggType,        // 蛋
        SausageType     // 肠
    }

    public interface IBatterCake
    {
        List<BcType> Type();
        double Coast();
    }

    public class NoneBatterCake : IBatterCake
    {
        public List<BcType> Type()
        {
            return new List<BcType> {BcType.None};
        }

        public double Coast()
        {
            return 0;
        }
    }

    /// <summary>
    /// 山东煎饼
    /// </summary>
    public class SdBatterCake : IBatterCake
    {
        public List<BcType> Type()
        {
            return new List<BcType> {BcType.SdCakeType};
        }

        public double Coast()
        {
            return 3.5;
        }
    }

    /// <summary>
    /// 鸡蛋
    /// </summary>
    public class Egg : IBatterCake
    {
        private readonly IBatterCake _batterCake = new NoneBatterCake();

        public Egg(IBatterCake mMoney)
        {
            _batterCake = mMoney;
        }

        public List<BcType> Type()
        {
            List<BcType> types = _batterCake.Type();
            types.AddRange(new List<BcType>() { BcType.EggType });
            return types;
        }

        public double Coast()
        {
            return 1 + _batterCake.Coast();
        }
    }

    /// <summary>
    /// 肠
    /// </summary>
    public class Sausage : IBatterCake
    {
        private readonly IBatterCake _batterCake = new NoneBatterCake();

        public Sausage(IBatterCake mMoney)
        {
            _batterCake = mMoney;
        }

        public List<BcType> Type()
        {
            List<BcType> types = _batterCake.Type();
            types.AddRange(new List<BcType>() { BcType.SausageType });
            return types;
        }

        public double Coast()
        {
            return 2 + _batterCake.Coast();
        }
    }

    /// <summary>
    /// 计算花费
    /// </summary>
    public class CalculateMoney : IBatterCake
    {
        private readonly IBatterCake _batterCake = new NoneBatterCake();
        public CalculateMoney(IBatterCake mMoney)
        {
            _batterCake = mMoney;
        }

        public List<BcType> Type()
        {
            return new List<BcType> {BcType.None};
        }

        public string Description()
        {
            List<BcType> types = _batterCake.Type();

            int eggs = 0, sausage = 0,battercakies = 0;
            for (int index = 0, count = types.Count(); index < count; index++)
            {
                if (types[index] == BcType.SdCakeType)
                    battercakies++;

                if (types[index] == BcType.EggType)
                    eggs++;

                if (types[index] == BcType.SausageType)
                    sausage++;
            }
            StringBuilder description = new StringBuilder();
            if (battercakies > 0)
                description.Append("煎饼").Append(battercakies).Append("个").Append("\n");

            if (eggs > 0)
                description.Append("鸡蛋").Append(eggs).Append("个").Append("\n");

            if (sausage > 0)
                description.Append("烤肠").Append(sausage).Append("个").Append("\n");

            return description.ToString();
        }

        public double Coast()
        {
            return _batterCake.Coast();
        }
    }

    public class Program
    {
        private static void Main(string[] args)
        {
            // 一个山东煎饼
            IBatterCake sdBatterCake = new SdBatterCake();
            // 一个鸡蛋
            IBatterCake egg1 = new Egg(sdBatterCake);
            // 再来个鸡蛋
            IBatterCake egg2 = new Egg(egg1);
            // 再来个肠
            IBatterCake sausage = new Sausage(egg2);

            CalculateMoney calculateMoney = new CalculateMoney(sausage);

            Console.WriteLine(calculateMoney.Description());
            Console.WriteLine("共花费 ： {0}", calculateMoney.Coast());
            Console.ReadLine();
        }
    }
}

看一下结果：

以下情况使用Decorator模式

1. 需要扩展一个类的功能，或给一个类添加附加职责。

2. 需要动态的给一个对象添加功能，这些功能可以再动态的撤销。

3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。

4. 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。