23中设计模式--行为型模式

14.职责链模式

#region 14.职责链模式(Chain Of Responsibility)。把请求的发送者和接受者松耦合，让多个对象都有机会接受请求，将这些对象连成一条链，让请求沿着这条链进行传递，直到有对象处理它为止。

    /// <summary>
    /// 请求类
    /// </summary>
    public class PurchaseRequest 
    {
        public double Amount { get; set; }
        public string Number { get; set; }
        public string Purpose { get; set; }


        public PurchaseRequest(double amount, string number, string purpose) 
        {
            this.Amount = amount;
            this.Number= number;
            this.Purpose = purpose;
        }
    }

    /// <summary>
    /// 抽象处理者
    /// </summary>
    public abstract class Approver
    {
        protected Approver successor;
        protected string name;

        public Approver(string name) 
        {
            this.name = name;
        }
        public void SetSuccessor(Approver successor) 
        {
            this.successor = successor;
        }

        public abstract void ProcessRequest(PurchaseRequest request);
    }

    /// <summary>
    /// 总监，具体处理类
    /// </summary>
    public class Director : Approver
    {
        public Director(string name) : base(name)
        {
        }

        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 50000)
            {
                Console.WriteLine("主管 {0} 审批采购单: {1}，金额: {2}元，采购目的: {3}。", this.name, request.Number, request.Amount, request.Purpose);

            }
            else 
            {
                this.successor.ProcessRequest(request);
            }
        }
    }
    /// <summary>
    /// 具体处理类
    /// </summary>
    public class VicePresident : Approver
    {
        public VicePresident(string name) : base(name)
        {
        }

        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 50000)
            {
                Console.WriteLine("主管 {0} 审批采购单: {1}，金额: {2}元，采购目的: {3}。", this.name, request.Number, request.Amount, request.Purpose);

            }
            else
            {
                this.successor.ProcessRequest(request);
            }
        }
    }

    #endregion

15.观察者模式

#region 15.观察者模式(Observer)。定义对象之间的一种一对多的依赖关系，使得当每一个对象状态发生改变时，其相关依赖对象皆得到通知并被自动更新。

    /// <summary>
    /// 抽象观察者
    /// </summary>
    public interface IObserver 
    {
        string Name { get; set; }
        void Help();
        void BeAttacked(AllyCountrolCenter acc);
    }

    /// <summary>
    /// 具体观察者
    /// </summary>
    public class Player : IObserver
    {
        public string Name { get ; set; }

        public void BeAttacked(AllyCountrolCenter acc)
        {
            Console.WriteLine("{0}: 我正被攻击，速来援救！",this.Name);
            acc.NotifyObserver(this.Name);
        }

        public void Help()
        {
            Console.WriteLine("{0} : 坚持住，立马来救你！",this.Name);
        }
    }

    /// <summary>
    /// 抽象目标
    /// </summary>
    public abstract class AllyCountrolCenter 
    {
        public string AllyName { get; set; }
        protected IList<IObserver> playerList = new List<IObserver>();

        public void Join(IObserver observer) 
        {
            playerList.Add(observer);
            Console.WriteLine("通知: {0} 加入 {1} 战队", observer.Name, this.AllyName);
        }
        public abstract void NotifyObserver(string name);
    }

    /// <summary>
    /// 具体目标
    /// </summary>
    public class ConcreteAllyControlCenter : AllyCountrolCenter
    {
        public ConcreteAllyControlCenter(string allyCountrolName) 
        {
            this.AllyName = allyCountrolName;
            Console.WriteLine("系统通知: {0} 战队组建成功!",this.AllyName);
        }
        public override void NotifyObserver(string playerName)
        {
            
            foreach (var player in playerList) 
            {
                Console.WriteLine("通知: 盟友们，{0}正遭受攻击,速去救援！", playerName);
            }
        }
    }

    #endregion

16.访问者模式

#region 16.访问者模式(Visitor)。提供一个作用于某对象结构中的各元素的操作表示，它使得可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

    /// <summary>
    /// 抽象元素
    /// </summary>
    public interface IEmployee 
    {
        void Accept(Department department);
    }

    /// <summary>
    /// 具体元素
    /// </summary>
    public class FullTimeEmployee : IEmployee
    {
        public string Name { get; set; }
        public double WeeklyWage { get; set; }
        public int WorkTime { get; set; }
        public FullTimeEmployee(string name,double weeklyWage,int workTime) 
        {
            this.Name = name;
            this.WeeklyWage = weeklyWage;
            this.WorkTime = workTime;
        }

        public void Accept(Department department)
        {
            department.Visit(this);
        }
    }

    /// <summary>
    /// 具体元素
    /// </summary>
    public class PartTimeEmployee : IEmployee
    {

        public string Name { get; set; }
        public double HourWage { get; set; }
        public int WorkTime { get; set; }
        public PartTimeEmployee(string name, double HourWage, int workTime)
        {
            this.Name = name;
            this.HourWage = HourWage;
            this.WorkTime = workTime;
        }
        public void Accept(Department department)
        {
            department.Visit(this);
        }
    }

    /// <summary>
    /// 抽象访问者
    /// </summary>
    public abstract class Department
    {
        public abstract void Visit(FullTimeEmployee employee);
        public abstract void Visit(PartTimeEmployee employee);
    }

    /// <summary>
    /// 具体访问者
    /// </summary>
    public class HRDepartment : Department
    {
        // 实现人力资源部对兼职员工数据的访问
        public override void Visit(PartTimeEmployee employee)
        {
            int workTime = employee.WorkTime;
            Console.WriteLine("临时工 {0} 实际工作时间为：{1} 小时", employee.Name, workTime);
        }

        // 实现人力资源部对全职员工数据的访问
        public override void Visit(FullTimeEmployee employee)
        {
            int workTime = employee.WorkTime;
            Console.WriteLine("正式员工 {0} 实际工作时间为：{1} 小时", employee.Name, workTime);

            if (workTime > 40)
            {
                Console.WriteLine("正式员工 {0} 加班时间为：{1} 小时", employee.Name, workTime - 40);
            }
            else if (workTime < 40)
            {
                Console.WriteLine("正式员工 {0} 请假时间为：{1} 小时", employee.Name, 40 - workTime);
            }
        }
    }

   /// <summary>
   /// 具体访问者
   /// </summary>
    public class FinancialDepartment : Department
    {
        // 实现财务部对兼职员工数据的访问
        public override void Visit(PartTimeEmployee employee)
        {
            int workTime = employee.WorkTime;
            double hourWage = employee.HourWage;
            Console.WriteLine("临时工 {0} 实际工资为：{1} 元", employee.Name, workTime * hourWage);
        }

        // 实现财务部对全职员工数据的访问
        public override void Visit(FullTimeEmployee employee)
        {
            int workTime = employee.WorkTime;
            double weekWage = employee.WeeklyWage;

            if (workTime > 40)
            {
                weekWage = weekWage + (workTime - 40) * 50;
            }
            else if (workTime < 40)
            {
                weekWage = weekWage - (40 - workTime) * 80;
                if (weekWage < 0)
                {
                    weekWage = 0;
                }
            }

            Console.WriteLine("正式员工 {0} 实际工资为：{1} 元", employee.Name, weekWage);
        }
    }

    #endregion

17.模板方法

#region 17.模板方法(Template Method)模式:定义一个操作中算法的框架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的特定步骤。


    /// <summary>
    /// 父类
    /// </summary>
    public abstract class Account 
    {
        public bool Validate(string account, string password) 
        {
            Console.WriteLine("账号 : {0}",account);
            Console.WriteLine("密码 : {0}",password);
            if (account.Equals("张无忌") && password.Equals("123456"))
                return true;
            else
                return false;
        }
        /// <summary>
        /// 延迟到子类中的方法步骤
        /// </summary>
        public abstract double CalculateInterest();
        public void Display() 
        {
            Console.WriteLine("显示利息");
        }
        public virtual bool IsAllowDisplay() 
        {
            return true;
        }
        public double GetInterest(string account, string password) 
        {
            var result = 0d;
            if (!Validate(account, password)) 
            {
                Console.WriteLine("账号或密码错误，请重新输入!");
                return result;
            }
            result = CalculateInterest();
            if (IsAllowDisplay()) 
            {
                Display();
                return result;
            }
            return 0d;
        }

    }
    /// <summary>
    /// 子类
    /// </summary>
    public class CurrentAccount : Account
    {
        public override double CalculateInterest()
        {
            Console.WriteLine("计算活期利息");
            return 10d;
        }
        public override bool IsAllowDisplay()
        {
            return base.IsAllowDisplay();
        }
    }

    #endregion

18.策略模式

#region 18. 策略模式(Strategy): 定义一系列算法类，将每一个算法封装起来，并让它们可以可以相互替换。策略模式让算法独立于使用它的客户而变化。

    /// <summary>
    /// 环境类
    /// </summary>
    public class MovieTicket 
    {
        private double _price;
        private IDiscount _discount;
        public double Price 
        {
            get { return _discount.Calculate(_price); }
            set { _price = value; }
        }
        public IDiscount Discount 
        {
            set { _discount = value; }
        }
    }


    /// <summary>
    /// 抽象策略类
    /// </summary>
    public interface IDiscount 
    {
        double Calculate(double price);
    }

    /// <summary>
    /// 具体策略
    /// 学生折扣
    /// </summary>
    public class StudentDiscount : IDiscount
    {
        public double Calculate(double price)
        {
            Console.WriteLine("学生票: ");
            return price * 0.8;
        }
    }

    /// <summary>
    /// 具体策略
    /// VIP折扣
    /// </summary>
    public class VIPDiscount : IDiscount
    {
        public double Calculate(double price)
        {
            Console.WriteLine("VIP票: ");
            Console.WriteLine("增加积分！");
            return price * 0.5;
        }
    }

    /// <summary>
    /// 具体策略
    /// 儿童票
    /// </summary>
    public class ChildrenDiscount : IDiscount
    {
        public double Calculate(double price)
        {
            Console.WriteLine("儿童票: ");
            return price - 10;
        }
    }

    #endregion

19.命令模式

#region 19.命令模式(Command): 将请求封装成对象，从而可以用不同的请求对客户进行参数化。

    /// <summary>
    /// 请求发送者
    /// </summary>
    public class FunctionButton 
    {
        public string Name { get; set; }
        private Command command;
        public FunctionButton(string name) 
        {
            this.Name = name;
        }

        public void SetCommand(Command command) 
        {
            this.command = command;
        }
        public void OnClick() 
        {

            Console.WriteLine("点击功能键");
            if (command != null) 
            {
                command.Execute();
            }
        }

    }

    /// <summary>
    /// 抽象请求者
    /// </summary>
    public abstract class Command 
    {
        public abstract void Execute();
    }

    /// <summary>
    /// 具体命令
    /// </summary>
    public class HelpCommand : Command
    {
        private HelpHandler hander;

        public HelpCommand() 
        {
            hander = new HelpHandler();
        }
        public override void Execute()
        {
            if (hander != null) 
            {
                hander.Display();
            }
        }
    }

    /// <summary>
    /// 具体命令
    /// </summary>
    public class MinimizeCommand : Command
    {
        private WindowHandler handler;
        public MinimizeCommand() 
        {
            handler = new WindowHandler();
        }
        public override void Execute()
        {
            if (handler != null) 
            {
                handler.Minimize();
            }
        }
    }

    /// <summary>
    /// 请求的接受者.
    /// </summary>
    public class WindowHandler 
    {
        public void Minimize() 
        {
            Console.WriteLine("正在最小化窗口至托盘...");
        }
    }

    public class HelpHandler 
    {
        public void Display() 
        {
            Console.WriteLine("正在显示帮助文档...");
        }
    }
    #endregion

20.备忘录模式

#region 20.备忘录模式(Memento): 在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样可以在以后将对象恢复到原先保存的状态。

    ///原发器
    public class Chessman 
    {
        public string Label { get; set; }
        public int X { get; set; }
        public int Y { get; set; }
        public Chessman(string label, int x, int y) 
        {
            Label = label;
            X = x;
            Y = y;
        }


    }
    /// <summary>
    /// 备忘录
    /// </summary>
    public class ChessmanMemento 
    {
        public string Label { get; set; }
        public int X { get; set; }
        public int Y { get; set; }
        public ChessmanMemento(string label, int x, int y) 
        {
            Label = label;
            X = x;
            Y = y;
        }
    }
    /// <summary>
    /// 负责人--单次备忘
    /// </summary>
    public class MementoCaretaker 
    {
        public ChessmanMemento Memento { get; set; }

    }

    /// <summary>
    /// 负责人--多次备忘
    /// </summary>
    public class NewMementoCaretoker 
    {
        private IList<ChessmanMemento> mementoList = new List<ChessmanMemento>();

        public ChessmanMemento GetMemento(int i) 
        {
            return mementoList[i];
        }

        public void SetMemento(ChessmanMemento memento) 
        {
            mementoList.Add(memento);
        }
    }

    #endregion

21.迭代器模式

#region 21.迭代器模式(Iterator): 提供一种方法来访问聚合对象，而不用暴露这个对象的内部标识，其别名为游标(Cursor)。
    
    /// <summary>
    /// 抽象聚合类
    /// </summary>
    public abstract class AbstractObjecList 
    {
        protected IList<object> objectList = new List<object>();

        public AbstractObjecList(IList<object> objectList) 
        {
            this.objectList = objectList;
        }

        public void AddObject(object obj) 
        {
            this.objectList.Add(obj);
        }

        public void RemoveObject(object obj) 
        {
            this.objectList.Remove(obj);
        }

        public IList<object> GetObjectList() 
        {
            return this.objectList;
        }

        /// <summary>
        /// 声明创建迭代器对象的抽象工厂
        /// </summary>
        public abstract IAbstractIterator CreateIterator();
    }

    /// <summary>
    /// 具体聚合类
    /// </summary>
    public class ProductList : AbstractObjecList
    {
        public ProductList(IList<object> objectList) : base(objectList)
        {
        }

        public override IAbstractIterator CreateIterator()
        {
            return new ProductIterator(this);
        }

        /// <summary>
        /// 具体迭代器
        /// </summary>
        public class ProductIterator : IAbstractIterator
        {
            private ProductList productList;
            private IList<object> products;
            private int cursor1;
            private int cursor2;

            public ProductIterator(ProductList productList) 
            {
                this.productList = productList;
                this.products = productList.GetObjectList();
                this.cursor1 = 0;
                this.cursor2 = this.products.Count - 1;
            }

            public object GetNextItem()
            {
                return products[cursor1];
            }

            public object GetPreviousItem()
            {
                return products[cursor2];
            }

            public bool IsFirst()
            {
                return cursor2 == -1;
            }

            public bool IsLast()
            {
                return cursor1 == products.Count;
            }

            public void Next()
            {
                if (cursor1 < products.Count) 
                {
                    cursor1++;
                }
            }

            public void Previous()
            {
                if (cursor2 > -1) 
                {
                    cursor2--;
                }
            }
        }
    }



    /// <summary>
    /// 抽象迭代器
    /// </summary>
    public interface IAbstractIterator 
    {
        void Next();
        bool IsLast();
        void Previous();
        bool IsFirst();
        object GetNextItem();
        object GetPreviousItem();
    }


    #endregion

22.中介者模式

#region 22.中介者模式(Mediator): 用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以相对独立地改变它们之间的交互。

    /// <summary>
    /// 抽象中介者.
    /// </summary>
    public abstract class Mediator 
    {
        public abstract void ComponentChanged(MediatorComponent c);
    }

    public class ConcreteMediator : Mediator
    {
        public Button addButton;
        public List list;
        public MediatorTextBox userNameTextBox;
        public ComboBox cb;

        public override void ComponentChanged(MediatorComponent c)
        {
            if (c == addButton)
            {
                Console.WriteLine("-- 点击添加按钮 --");
                list.Update();
                cb.Update();
                userNameTextBox.Update();
            }
            else if (c == list)
            {
                Console.WriteLine("-- 从列表框选择客户 --");
                cb.Select();
                userNameTextBox.SetText();
            }
            else if (c == cb) 
            {
                Console.WriteLine("-- 从组合框选择客户 --");
                cb.Select();
                userNameTextBox.SetText();
            }
        }
    }

    /// <summary>
    /// 抽象组件
    /// </summary>
    public abstract class MediatorComponent
    {
        protected Mediator mediator;

        public void SetMediator(Mediator mediator) 
        {
            this.mediator = mediator;
        }

        public void Changed() 
        {
            mediator.ComponentChanged(this);
        }
        public abstract void Update();
    }

    #region 具体组件

    public class Button : MediatorComponent
    {

        public override void Update()
        {
            throw new NotImplementedException();
        }
    }

    public class List : MediatorComponent
    {
        public override void Update()
        {
            Console.WriteLine("列表框增加一项: 张无忌");
        }
        public void Select() 
        {
            Console.WriteLine("列表框选中项: 小龙女");
        }
    }

    public class ComboBox : MediatorComponent
    {
        public override void Update()
        {
            Console.WriteLine("组合框增加一项: 张无忌");
        }
        public void Select() 
        {
            Console.WriteLine("组合框选中项: 小龙女");
        }
    }

    public class MediatorTextBox : MediatorComponent
    {
        public override void Update()
        {
            Console.WriteLine("客户信息增加成功后文本框清空");
        }
        public void SetText() 
        {
            Console.WriteLine("文本框显示: 小龙女");
        }
    }

    public class Label : MediatorComponent
    {
        public override void Update()
        {
            Console.WriteLine("文本标签内容改变，客户信息总数量加1");
        }
    }


    #endregion


    #endregion

23解释器模式

#region 23.解释器模式(Interpreter): 定义一个语言的文法，并且建立一个解释器来解释该语言中的句子。

    /// <summary>
    /// 环境类
    /// </summary>
    public class Context 
    {
        private int index = -1;
        private string[] tokens;
        private string currentToken;
        public Context(string text) 
        {
            text = text.Replace("  ", " ");
            tokens = text.Split(' ');
            
        }
        public string NextToken() 
        {
            if (index < tokens.Length - 1)
            {
                currentToken = tokens[++index];
            }
            else 
            {
                currentToken = null;
            }
            return currentToken;
        }

        public string GetCurrentToken() 
        {
            return currentToken;
        }

        public void SkipToken(string token) 
        {
            if (!token.Equals(currentToken, StringComparison.OrdinalIgnoreCase)) 
            {
                Console.WriteLine("错误提示:{0} 解释错误！", currentToken);
            }
            NextToken();
        }

        public int GetCurrentNumber() 
        {
            int number = 0;
            try
            {
                number = Convert.ToInt32(currentToken);
            }
            catch (Exception ex) 
            {
                Console.WriteLine("错误提示: {0}", ex.Message);
            }
            return number;
        }
    }

    /// <summary>
    /// 抽象表达式
    /// </summary>
    public abstract class Node 
    {
        public abstract void Interpret(Context context);
        public abstract void Execute();
    }

    //public class ExpressionNode : Node
    //{

    //    private IList<Node> nodeList = new List<Node>();

    //    public override void Execute()
    //    {
            
    //    }

    //    //public override void Interpret(Context context)
    //    //{
    //    //    while (true) 
    //    //    {
    //    //        if (context.GetCurrentToken() == null)
    //    //        {
    //    //            break;
    //    //        }
    //    //        else if (context.GetCurrentToken().Equals("END", StringComparison.OrdinalIgnoreCase))
    //    //        {
    //    //            context.SkipToken("END");
    //    //            break;
    //    //        }
    //    //        else 
    //    //        {
    //    //            node.Interpret(context);
    //    //            nodeList.Add(node);
    //    //        }
    //    //    }
    //    //}
    //}

    #endregion