14/23 装饰器模式

装饰器模式（Decorator Pattern）

允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

使用场景：

1. 扩展一个类的功能。
2. 动态增加功能，动态撤销。
3. [AOP设计常见设计、后续博客会讲述…]

现在我们写了一个很强大同时又非常复杂的功能。如下为该算法[由于只是模拟故，所以乱写一通]

public interface IOperator
{
    void Operator();
}

public class Operator01 : IOperator
{
    public void Operator()
    {
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                Console.WriteLine(i*j);
            }
        }
    }
}
public class Operator02 : IOperator
{
    public void Operator()
    {
        Console.WriteLine("121212312");
        Console.WriteLine("121212312");
        Console.WriteLine("121212312");
        Console.WriteLine("121212312");
    }
}

public class OperatorFactory
{
    public static IOperator GetOperator(OperatorType pOperatorType)
    {
        IOperator pOperator = null;
        switch (pOperatorType)
        {
            case OperatorType.Oper01:
                pOperator = new Operator01();
                break;
            case OperatorType.Oper02:
                pOperator = new Operator02();
                break;
        }
        return pOperator;
    }
}
public enum OperatorType
{
    Oper01,
    Oper02
}

private void btnRunOperator_Click(object sender, EventArgs e)
{
    IOperator pOperator = OperatorFactory.GetOperator(OperatorType.Oper01);
    pOperator.Operator();
}

现在要将Operator01 算子循环调用10次，那么我们为了不将算法重新实现一次，而为了遵循开闭原则我们，将对象包装一层：

public class Operator01 : IOperator
{
    public virtual void Operator()
    {
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < 10; j++)
            {
                Console.WriteLine(i*j);
            }
        }
    }
}
public class Operator01_Batch : Operator01
{
    public override void Operator()
    {
        Console.WriteLine("写入日志信息");
        base.Operator();
    }
}

public abstract class AbstractEquipment
{
    public int Id { get; set; }
    public string Name { get; set; }
    public abstract void Attack();
}
public class Gun : AbstractEquipment
{
    public override void Attack()
    {
        Console.WriteLine("用枪攻击");
    }
}
class Sword : AbstractEquipment
{
    public override void Attack()
    {
        Console.WriteLine("用剑攻击");
    }
}
public class GunInherit:Gun
{
    public override void Attack()
    {
        base.Attack();
        Console.WriteLine("善恶值增加");
    }
}

//组合
public class EquipmentCombination
{
    private AbstractEquipment _equipment = null;
    public EquipmentCombination(AbstractEquipment equipment)
    {
        _equipment = equipment;
    }
    public void Attack()
    {
        _equipment.Attack();
        Console.WriteLine("善恶值增加");
    }
}
public class BaseEquipmentDecorator : AbstractEquipment
{
    private AbstractEquipment _equipment = null;
    public BaseEquipmentDecorator(AbstractEquipment equipment)
    {
        _equipment = equipment;
    }
    public override void Attack()
    {
        _equipment.Attack();
    }
}
public class EquipmentStrengthenDecorator:BaseEquipmentDecorator
{
    //调用直接父类的指定构造函数
    public EquipmentStrengthenDecorator(AbstractEquipment equipment)
        :base(equipment)
    {
    }
    public override void Attack()
    {
        base.Attack();
        Strengthen();
    }
    public void Strengthen()
    {
        Console.WriteLine("武器被强化");
    }
}

界面调用
        private void button1_Click(object sender, EventArgs e)
        {
            AbstractEquipment gun = new Gun();
            gun = new EquipmentStrengthenDecorator(gun);
            gun.Attack();
        }