设计模式行为型上[2]

1:状态模式

概念

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

状态模式包含以下主要角色。
1.环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
2.抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
3.具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。

类图

代码

namespace 状态模式
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Context c = new Context(new ConcreteStateA());
            //开始调用,虽然看起来是同样的调用但是状态一直在变
            c.Requet();
            c.Requet();
            c.Requet();
            c.Requet();
        }
    }

    class Context
    {
        private State state;
        //定义初始状态
        public Context(State state)
        {
            this.state = state;
        }
        //可读写属性状态
        public State State
        {
            get { return state; }
            set { state = value; }
        }
        //对请求做处理
        public void Requet()
        {
            state.Handle(this);
        }
    }

    abstract class State
    {
        public abstract void Handle(Context context);
    }
    //具体子类
    class ConcreteStateA : State
    {
        public override void Handle(Context context)
        {
            //状态A的下一状态是状态B
            context.State = new ConcreteStateB();
        }
    }
    //具体子类B
    class ConcreteStateB : State
    {
        public override void Handle(Context context)
        {
            //状态B的下一状态是状态A  
            context.State = new ConcreteStateA();
        }
    }
}

观察者模式

概念

多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。它是对象行为型模式。

类图

代码

namespace 观察者模式
{
    internal class Program
    {
        static void Main(string[] args)
        {
            ConcreteSubject s = new ConcreteSubject();

            s.Attach(new ConcreteObserver(s,"X"));
            s.Attach(new ConcreteObserver(s, "Y"));
            s.Attach(new ConcreteObserver(s, "Z"));

            s.SubjectState = "ABC";
            s.Notify();

            Console.ReadLine();
            
        }
    }

    abstract class Observer
    {
        public abstract void Update();
    }

    class ConcreteObserver : Observer
    {
        private string name;
        private string observerState;
        private ConcreteSubject subject;
        //构造函数
        public ConcreteObserver(ConcreteSubject subject, string name)
        {
            this.subject = subject;
            this.name = name;
        }
        //通知
        public override void Update()
        {
            observerState = subject.SubjectState;
            Console.WriteLine("观察者{0}的新状态是{1}",name,observerState);
        }

        public ConcreteSubject Subject
        {
            get { return subject; }
            set { subject = value; }
        }
    }

    class ConcreteSubject : Subject
    {
        private string subjectState;    //具体被观察者状态
        public string SubjectState
        {
            get { return subjectState; }
            set { subjectState = value; }
        }
    }
    abstract class Subject
    {
        private IList<Observer> observers = new List<Observer>();
        //增加观察者
        public void Attach(Observer observer)
        {
            observers.Add(observer);
        }
        //移除观察者
        public void Detach(Observer observer)
        {
            observers.Remove(observer);
        }
        //通知
        public void Notify()
        {
            foreach (Observer o in observers)
            {
                o.Update();
            }
        }
    }
}

备忘录

概念

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。

类图

代码

namespace 备忘录模式
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Originator o = new Originator();
            o.State = "On";
            
            Caretaker c = new Caretaker();
            c.Memento = o.CreteMemento();

            o.State = "Off";

            o.SetMemento(c.Memento);
           
        }
    }
    class Memento
    {
        private string state;
        public Memento(string state)
        {
            this.state = state;
        }
        public string State
        {
            get { return state; }
        }
    }
    class Originator
    {
        private string state;
        public string State
        {
            get { return state; }
            set { state = value; }
        }

        public Memento CreteMemento()
        {
            return (new Memento(state));
        }

        public void SetMemento(Memento memento)
        {
          state =  memento.State;
        }
    }

    class Caretaker
    {
        private Memento memento;
        public Memento Memento
        {
            get { return memento; }
            set { memento = value; }
        }
    }
}