一页中总结行为类型的设计模式

/// <summary>
/// 请款请求实体对象
/// </summary>
class Loan
{
    public double Amount { get; set; }
    public string Purpose { get; set; }
    public int Number { get; set; }
}

//定义事件参数，保留请求的主题内容
public class LoanEventArgs : EventArgs
{
    internal Loan Loan { get; set; }
}

/// <summary>
/// 为处理请求对象定义基类
/// </summary>
abstract class Approver
{
    // 请款事件
    public EventHandler<LoanEventArgs> Loan;

    // 请款动作，给事件执行
    public abstract void LoanHandler(object sender, LoanEventArgs e);

    // 构造函数，初始化时将动作绑定到事件
    public Approver()
    {
        Loan += LoanHandler;
    }

    //触发事件
    public void ProcessRequest(Loan loan)
    {
        OnLoan(new LoanEventArgs { Loan = loan });
    }

    // 执行请款事件请求
    public virtual void OnLoan(LoanEventArgs e)
    {
        if (Loan != null)
        {
            Loan(this, e);
        }
    }

    // 设置或者获取下一个处理者
    public Approver Successor { get; set; }
}

/// <summary>
/// 财务
/// </summary>
class Clerk : Approver
{
    public override void LoanHandler(object sender, LoanEventArgs e)
    {
        //我的责任范围我处理
        if (e.Loan.Amount < 25000.0)
        {
            Console.WriteLine("{0} 批准# {1}",
            this.GetType().Name, e.Loan.Number);
        }
        //不是就给下一个处理吧
        else if (Successor != null)
        {
            Successor.LoanHandler(this, e);
        }
    }
}

/// <summary>
/// 经理
/// </summary>
class AssistantManager : Approver
{
    public override void LoanHandler(object sender, LoanEventArgs e)
    {
        if (e.Loan.Amount < 45000.0)
        {
            Console.WriteLine("{0} 批准# {1}",
            this.GetType().Name, e.Loan.Number);
        }
        else if (Successor != null)
        {
            Successor.LoanHandler(this, e);
        }
    }
}

/// <summary>
/// 总经理
/// </summary>
class Manager : Approver
{
    public override void LoanHandler(object sender, LoanEventArgs e)
    {
        if (e.Loan.Amount < 100000.0)
        {
            Console.WriteLine("{0} 批准# {1}",
            sender.GetType().Name, e.Loan.Number);
        }
        else if (Successor != null)
        {
            Successor.LoanHandler(this, e);
        }
        else
        {
            Console.WriteLine(
            "请求# {0} 得开个会研究了!",
            e.Loan.Number);
        }
    }
}



/// <summary>
/// 客户端调用
/// </summary>
class Program
{
    static void Main(string[] args)
    {
        // 处理者对象
        Approver rohit = new Clerk();
        Approver rahul = new AssistantManager();
        Approver manoj = new Manager();

        //定义下一个处理者责任链
        rohit.Successor = rahul;
        rahul.Successor = manoj;

        // 请求1
        var loan = new Loan { Number = 2034, Amount = 24000.00, Purpose = "小金额" };
        rohit.ProcessRequest(loan);
        // 请求2
        loan = new Loan { Number = 2035, Amount = 42000.10, Purpose = "一般金额" };
        rohit.ProcessRequest(loan);
        // 请求3
        loan = new Loan { Number = 2036, Amount = 156200.00, Purpose = "大金额" };
        rohit.ProcessRequest(loan);

        Console.ReadKey();
    }
}

public class Light
    {
        public void TurnOn()
        {
            Console.WriteLine("开灯");
        }

        public void TurnOff()
        {
            Console.WriteLine("关灯");
        }
    }

    /// <summary>
    /// 命令角色接口
    /// </summary>
    public interface ICommand
    {
        void Execute();
    }

    /// <summary>
    /// 具体命令实现类，负责开灯。
    /// </summary>
    public class FlipUpCommand : ICommand
    {
        private Light _light;

        public FlipUpCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.TurnOn();
        }
    }

    /// <summary>
    /// 具体命令实现 负责关灯
    /// </summary>
    public class FlipDownCommand : ICommand
    {
        private Light _light;

        public FlipDownCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.TurnOff();
        }
    }
    /// <summary>
    /// 命令请求角色，调用执行命令
    /// </summary>
    public class Switch
    {
        private List<ICommand> _commands = new List<ICommand>();

        public void StoreAndExecute(ICommand command)
        {
            _commands.Add(command);
            command.Execute();
        }
    }
    /// <summary>
    /// 客户端调用
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("输入命令 (ON/OFF) : ");
            string cmd = Console.ReadLine();
            Light lamp = new Light();//命令接收

            //下边就是精华，就是将命令的请求和执行分开，弱化请求和执行的耦合关系
            ICommand switchUp = new FlipUpCommand(lamp);//封装具体指令 
            ICommand switchDown = new FlipDownCommand(lamp);//封装具体指令

            Switch s = new Switch();//命令请求执行

            if (cmd == "ON")
            {
                s.StoreAndExecute(switchUp);
            }
            else if (cmd == "OFF")
            {
                s.StoreAndExecute(switchDown);
            }
            else
            {
                Console.WriteLine("命令 \"ON\" or \"OFF\" 必须发出.");
            }

            Console.ReadKey();
        }
    }

/// <summary>
    /// 迭代器接口
    /// </summary>
    interface IIterator
    {
        string FirstItem { get; }
        string NextItem { get; }
        string CurrentItem { get; }
        bool IsDone { get; }
    }
    
    /// <summary>
    /// 聚合类接口
    /// </summary>
    interface IAggregate
    {
        IIterator GetIterator();
        //创建索引
        string this[int itemIndex] { set; get; }
        int Count { get; }
    }
    /// <summary>
    /// 聚合类实现
    /// </summary>
    class MyAggregate : IAggregate
    {
        List<string> values_ = null;

        public MyAggregate()
        {
            values_ = new List<string>();
        }

        #region IAggregate Members

        public IIterator GetIterator()
        {
            //返回一下实现的迭代器实例，把聚合类本身传递给迭代器
            return new MyIterator(this);
        }

        #endregion

        public string this[int itemIndex]
        {
            get
            {
                if (itemIndex < values_.Count)
                {
                    return values_[itemIndex];
                }
                else
                {
                    return string.Empty;
                }
            }
            set
            {
                values_.Add(value);
            }
        }

        public int Count
        {
            get
            {
                return values_.Count;
            }
        }
    }
    /// <summary>
    /// 迭代器实现
    /// </summary>
    class MyIterator : IIterator
    {
        IAggregate aggregate_ = null;
        int currentIndex_ = 0;

        public MyIterator(IAggregate aggregate)
        {
            aggregate_ = aggregate;
        }

        #region IIterator Members

        public string FirstItem
        {
            get
            {
                currentIndex_ = 0;
                return aggregate_[currentIndex_];
            }
        }

        public string NextItem
        {
            get
            {
                currentIndex_ += 1;

                if (IsDone == false)
                {
                    return aggregate_[currentIndex_];
                }
                else
                {
                    return string.Empty;
                }
            }
        }

        public string CurrentItem
        {
            get
            {
                return aggregate_[currentIndex_];
            }
        }

        public bool IsDone
        {
            get
            {
                if (currentIndex_ < aggregate_.Count)
                {
                    return false;
                }
                return true;
            }
        }

        #endregion
    }
    class Program
    {
        static void Main(string[] args)
        {
            MyAggregate aggr = new MyAggregate();

            aggr[0] = "1";
            aggr[1] = "2";
            aggr[2] = "3";
            aggr[3] = "4";
            aggr[4] = "5";
            aggr[5] = "6";
            aggr[6] = "7";
            aggr[7] = "8";
            aggr[8] = "9";
            aggr[9] = "10";

            IIterator iter = aggr.GetIterator();

            for (string s = iter.FirstItem; iter.IsDone == false; s = iter.NextItem)
            {
                Console.WriteLine(s);
            }
            Console.ReadKey();
        }
    }

//参与者基类
public interface IColleague<t>
{
//发送信息
    void SendMessage(IMediator<t> mediator, T message);
//接收信息
    void ReceiveMessage(T message);
}
//参与者具体泪
public class ConcreteColleague<t> : IColleague<t>
{
    private string name;

    public ConcreteColleague(string name)
    {
        this.name = name;
    }

    void IColleague<t>.SendMessage(IMediator<t> mediator, T message)
    {
        mediator.DistributeMessage(this, message);
    }

    void IColleague<t>.ReceiveMessage(T message)
    {
        Console.WriteLine(this.name + " received " + message.ToString());
    }
}

//中介者基类
public interface IMediator<t>
{
  //参与者列表
    List<icolleague><t>> ColleagueList { get; }
 //分发信息
    void DistributeMessage(IColleague<t> sender, T message);
//注册加入参与人
    void Register(IColleague<t> colleague);
}

//中介者具体实现类
public class ConcreteMediator<t> : IMediator<t>
{
    private List<icolleague><t>> colleagueList = new List<icolleague><t>>();

    List<icolleague><t>> IMediator<t>.ColleagueList
    {
        get { return colleagueList; }
    }

    void IMediator<t>.Register(IColleague<t> colleague)
    {
        colleagueList.Add(colleague);
    }

    void IMediator<t>.DistributeMessage(IColleague<t> sender, T message)
    {
        foreach (IColleague<t> c in colleagueList)
            if (c != sender)    //发送者不接收信息
                c.ReceiveMessage(message);
    }
}
//客户端调用
class Program
{
    static void Main(string[] args)
    {
        //参与同事列表
        IColleague<string> colleagueA = new ConcreteColleague<string>("ColleagueA");
        IColleague<string> colleagueB = new ConcreteColleague<string>("ColleagueB");
        IColleague<string> colleagueC = new ConcreteColleague<string>("ColleagueC");
        IColleague<string> colleagueD = new ConcreteColleague<string>("ColleagueD");

        //第一个传递消息中介
        IMediator<string> mediator1 = new ConcreteMediator<string>();
        //注册参与者到中介
        mediator1.Register(colleagueA);
        mediator1.Register(colleagueB);
        mediator1.Register(colleagueC);
        //参与者A发出一条信息
        colleagueA.SendMessage(mediator1, "来自A的信息");

        //第二个中介者
        IMediator<string> mediator2 = new ConcreteMediator<string>();
        //将参与者注册到中介者中
        mediator2.Register(colleagueB);
        mediator2.Register(colleagueD);
        //参与者B发出一条信息
        colleagueB.SendMessage(mediator2, "b中介发出一条信息");
    }
}

//备忘录实体对象，存储发起人对象的状态
public class Memento<T>
{
    private T state;

    public T GetState()
    {
        return state;
    }

    public void SetState(T state)
    {
        this.state = state;
    }
}

//发起人对象，
public class Originator<T>
{
    private T state;

    //创建备忘录并保存状态进去
    public Memento<T> CreateMemento()
    {
        Memento<T> m = new Memento<T>();
        m.SetState(state);
        return m;
    }

    //从备忘录中恢复对象
    public void SetMemento(Memento<T> m)
    {
        state = m.GetState();
    }

    //保存状态到发起人
    public void SetState(T state)
    {
        this.state = state;
    }

    //show
    public void ShowState()
    {
        Console.WriteLine(state.ToString());
    }
}

//备忘录管理者
public static class Caretaker<T>
{
    //状态列表
    private static List<Memento<T>> mementoList = new List<Memento<T>>();

    //保存发起人创建的备忘录
    public static void SaveState(Originator<T> orig)
    {
        mementoList.Add(orig.CreateMemento());
    }

    //恢复备忘录给发起人
    public static void RestoreState(Originator<T> orig, int stateNumber)
    {
        orig.SetMemento(mementoList[stateNumber]);
    }
}

    class Program
{
    static void Main(string[] args)
    {
        //创建发起人
        Originator<string> orig = new Originator<string>();

        orig.SetState("state0");
        Caretaker<string>.SaveState(orig); //管理者保存发起人的备忘录
        orig.ShowState();

        orig.SetState("state1");
        Caretaker<string>.SaveState(orig); 
        orig.ShowState();

        orig.SetState("state2");
        Caretaker<string>.SaveState(orig); 
        orig.ShowState();

        //管理者恢复状态给发起人
        Caretaker<string>.RestoreState(orig, 0);
        orig.ShowState();  // state0
    }
}

/// <summary>
    /// 主体基类 (一个仓库库存变化通知的例子)
    /// </summary>
    interface ISubject
    {
        void Subscribe(Observer observer);
        void Unsubscribe(Observer observer);
        void Notify();
    }
    /// <summary>
    /// 主体实现类
    /// </summary>
    public class Subject : ISubject
    {
        private List<Observer> observers = new List<Observer>();
        private int _int;
        public int Inventory
        {
            get
            {
                return _int;
            }
            set
            {
                // 确保库存数量有变化，由主体通知给观察者
                if (value > _int)
                    Notify();
                _int = value;
            }
        }
        public void Subscribe(Observer observer)
        {
            observers.Add(observer);
        }

        public void Unsubscribe(Observer observer)
        {
            observers.Remove(observer);
        }

        public void Notify()
        {
            observers.ForEach(x => x.Update());
        }
    }

    /// <summary>
    /// 观察者基类
    /// </summary>
    interface IObserver
    {
        void Update();
    }
    /// <summary>
    /// 观察者具体实现类
    /// </summary>
    public class Observer : IObserver
    {
        public string ObserverName { get; private set; }
        public Observer(string name)
        {
            this.ObserverName = name;
        }
        public void Update()
        {
            Console.WriteLine("{0}: 增加了一个产品到仓库", this.ObserverName);
        }
    }
    /// <summary>
    /// 客户端调用
    /// </summary>
    class program {
        static void Main(string[] args)
        {
            Subject subject = new Subject();
            // 注册一个观察者
            Observer observer1 = new Observer("Observer 1");
            subject.Subscribe(observer1);
            // 2
            subject.Subscribe(new Observer("Observer 2"));
            subject.Inventory++;  //增加库存
            // 删除一个观察者，增加观察者3
            subject.Unsubscribe(observer1);
            subject.Subscribe(new Observer("Observer 3"));
            subject.Inventory++;
            Console.ReadLine();
        }
    }

 /// <summary>
    /// ATM机对象
    /// </summary>
    public class ATM
    {
        public ATMState currentState = null;

        public ATM()
        {
            currentState = new NoCardState(1000, this); //初始化atm机位没卡状态
        }

        public void StartTheATM()
        {
            while (true)
            {
                Console.WriteLine(currentState.GetNextScreen()); //继续下一个步骤
            }
        }
    }
    /// <summary>
    /// 定义ATM机的状态
    /// </summary>
    public abstract class ATMState
    {
        private ATM atm;

        public ATM Atm
        {
            get { return atm; }
            set { atm = value; }
        }
        private int dummyCashPresent = 1000;

        public int DummyCashPresent
        {
            get { return dummyCashPresent; }
            set { dummyCashPresent = value; }
        }

        public abstract string GetNextScreen();
    }
    /// <summary>
    /// 没卡时的状态实现
    /// </summary>
    class NoCardState : ATMState
    {
        public NoCardState(ATMState state)
            : this(state.DummyCashPresent, state.Atm)
        {

        }
        public NoCardState(int amountRemaining, ATM atmBeingUsed)
        {
            this.Atm = atmBeingUsed;
            this.DummyCashPresent = amountRemaining;
        }

        public override string GetNextScreen()
        {
            Console.WriteLine("请输入密码");
            string userInput = Console.ReadLine();

            // 验证改变当前状态
            if (userInput.Trim() == "1234")
            {
                UpdateState();
                return "取多少钱啊？";
            }

            return "没验证过";
        }

        private void UpdateState()
        {
            Atm.currentState = new CardValidatedState(this);
        }
    }
    /// <summary>
    /// 验证通过的状态
    /// </summary>
    class CardValidatedState : ATMState
    {
        public CardValidatedState(ATMState state)
            : this(state.DummyCashPresent, state.Atm)
        {

        }
        public CardValidatedState(int amountRemaining, ATM atmBeingUsed)
        {
            this.Atm = atmBeingUsed;
            this.DummyCashPresent = amountRemaining;
        }

        public override string GetNextScreen()
        {
            string userInput = Console.ReadLine();

            int requestAmount;
            bool result = Int32.TryParse(userInput, out requestAmount);

            if (result == true)
            {
                if (this.DummyCashPresent < requestAmount)
                {
                    return "atm没那么多钱给你取！";
                }

                this.DummyCashPresent -= requestAmount;
                UpdateState();  //要么进入没钱状态，要么就进入吐钱状态,篇幅有限，直接进入初始没卡状态算了

                return string.Format(@" {0}钱被你取到了，回车继续", requestAmount);
            }

            return "输入正确数字";
        }

        private void UpdateState()
        {
            //if (this.DummyCashPresent == 0)
            //{
            //    Atm.currentState = new NoCashState(this);
            //}
            //else
            //{
             //   Atm.currentState = new CashWithdrawnState(this);
            //}
            Atm.currentState = new NoCardState(this);
        }
    }
    /// <summary>
    /// 客户端调用
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            TestWithStatePattern();
        }

        private static void TestWithStatePattern()
        {
            ATM atm = new ATM();

            atm.StartTheATM();
        }
    }

/// <summary>
    /// 定义一个策略枚举，无关紧要，看你在应用环境中怎么判断
    /// </summary>
    public enum ObjectToSort
    {
        StudentNumber,
        RailwayPassengers
    }
    /// <summary>
    /// 策略行为基类
    /// </summary>
    public interface ISortingStrategy
    {
        void Sort<T>(List<T> dataToBeSorted);
    }
    /// <summary>
    /// 策略行为具体实现。快速排序
    /// </summary>
    public class QuickSort : ISortingStrategy
    {
        public void Sort<T>(List<T> dataToBeSorted)
        {
            //逻辑代码
        }
    }
    /// <summary>
    ///策略行为具体实现。 合并排序
    /// </summary>
    public class MergeSort : ISortingStrategy
    {
        public void Sort<T>(List<T> dataToBeSorted)
        {
            //逻辑代码
        }
    }
    /// <summary>
    /// 客户调用
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            ISortingStrategy sortingStrategy = null;

            List<int> studentNumbers = new List<int> { 123, 678, 543, 189 };
            sortingStrategy = GetSortingOption(ObjectToSort.StudentNumber);
            sortingStrategy.Sort(studentNumbers);

            List<string> railwayPassengers = new List<string> { "A21", "Z2", "F3", "G43" };
            sortingStrategy = GetSortingOption(ObjectToSort.RailwayPassengers);
            sortingStrategy.Sort(railwayPassengers);

        }
        /// <summary>
        /// 调用环境
        /// </summary>
        /// <param name="objectToSort"></param>
        /// <returns></returns>
        private static ISortingStrategy GetSortingOption(ObjectToSort objectToSort)
        {
            ISortingStrategy sortingStrategy = null;

            switch (objectToSort)
            {
                case ObjectToSort.StudentNumber:
                    sortingStrategy = new MergeSort();
                    break;
                case ObjectToSort.RailwayPassengers:
                    sortingStrategy = new QuickSort();
                    break;
                default:
                    break;
            }
            return sortingStrategy;
        }
    }

/// <summary>
    /// 模板基类
    /// </summary>
    abstract class DataExporter
    {
        public void ReadData()
        {
            Console.WriteLine("从SqlServer中读数据");
        }

        public void FormatData()
        {
            Console.WriteLine("格式化每次请求的数据");
        }

        // 这个基类根据导出的文件类型不同 有不同的实现方式
        public abstract void ExportData();

        // 客户端将调用这个模板方法
        public void ExportFormatedData()
        {
            this.ReadData();
            this.FormatData();
            this.ExportData();
        }
    }

    /// <summary>
    /// 导出excel
    /// </summary>
    class ExcelExporter : DataExporter
    {
        public override void ExportData()
        {
            Console.WriteLine("导出数据到excel文件.");
        }
    }
    /// <summary>
    /// 导出pdf
    /// </summary>
    class PDFExporter : DataExporter
    {
        public override void ExportData()
        {
            Console.WriteLine("导出数据到pdf文件.");
        }
    }
    /// <summary>
    /// 客户端调用
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            DataExporter exporter = null;

            exporter = new ExcelExporter();
            exporter.ExportFormatedData();

            Console.WriteLine();

            exporter = new PDFExporter();
            exporter.ExportFormatedData();
        }
    }

 /// <summary>
    /// 基础数据元素基类，稳定且可能不变的
    /// </summary>
    public abstract class DocumentPart
    {
        public string Text { get; private set; }
        public abstract void Accept(IVisitor visitor);
    }

    /// <summary>
    /// 以下三个类的Accept方法都使用同一个访问者，根据传递自身对象不同，而调用不同的访问者中的重载操作方法
    /// </summary>
    public class PlainText : DocumentPart
    {
        public override void Accept(IVisitor visitor)
        {
            visitor.Visit(this); //传递自身到访问中方法中
        }
    }

    public class BoldText : DocumentPart
    {
        public override void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    }

    public class Hyperlink : DocumentPart
    {
        public string Url { get; private set; }

        public override void Accept(IVisitor visitor)
        {
            visitor.Visit(this);
        }
    }
//结构对象
    public class Document
    {
        private List<DocumentPart> m_parts;

        public void Accept(IVisitor visitor)
        {
            foreach (DocumentPart part in this.m_parts)
            {
                //2 文档中的节点调用访问中中的不同方法
                part.Accept(visitor);//文档中每个节点都用一个访问者对象
            }
        }
    }

    /// <summary>
    /// 访问者基类（作用域基础结构的操作）
    /// </summary>
    public interface IVisitor
    {
        void Visit(PlainText docPart);
        void Visit(BoldText docPart);
        void Visit(Hyperlink docPart);
    }
    /// <summary>
    /// 访问者具体实现类  
    /// </summary>
    public class HtmlVisitor : IVisitor
    {
        public string Output
        {
            get { return this.m_output; }
            set { m_output = value; }
        }
        private string m_output = "";

        public void Visit(PlainText docPart)
        {
            this.Output += docPart.Text;
        }

        public void Visit(BoldText docPart)
        {
            this.m_output += "<b>" + docPart.Text + "</b>";
        }

        public void Visit(Hyperlink docPart)
        {
            this.m_output += "<a href=\"" + docPart.Url + "\">" + docPart.Text + "</a>";
        }
    }
    /// <summary>
    /// 客户端调用
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            Document doc = new Document();
            HtmlVisitor visitor = new HtmlVisitor();
            doc.Accept(visitor); //1 这里把访问者传递给结构对象
            Console.WriteLine("Html:\n" + visitor.Output);
        }
    }