设计模式二

接设计模式一

当然这个receiver类是需要外界去调用，我们就需要一个执行类command，这个是具体执行类，在这个里面我们需要管理receiver，外界通过这个去调用receiver，这个command类就相当于经纪人。最后一个类就是invoker,这个类是一个中心，因为我们的需求是多变的，所以我们的receiver与command将会非常多的，那么我们就将设置一个中心管理类来一起去管理他们，这个类就是invoker，他负责我们去执行什么命令，去调用什么方法。

网上的这句话非常好，一起开看看。命令模式的本质就是对命令进行分装，将发送命令与执行命令的责任分开。每一个命令都是要给操：请求的一个发送请求，要执行要给操作；接受的一方都到请求操作。请求方和接收方独立开来，使得请求的一方不必知道接收请求一个的接口，更不必知道请求是怎么被接收的。以及操作是否被执行，何时被执行，以及是怎么被执行的。这里我们要知道，在软件工程中一个非常重要的思想就是分装的思想，将方法就行封装，外界不必知道它的构成，外界就是一个调用者，他只需要值发送命令就好了，这样功能就比较单一，这个就符合单一职责原则，代码耦合性性就大大降低。

命令模式使请求本身成为一个对象，这个对象和其他对象一个可以被存储和传递。命令模式的关键在于引入了抽象命令接口，且发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。

命令模式的优点：解除了请求者与实现者之间的耦合，降低了系统的耦合度。对请求排队或记录请求日志，支持撤销操作。可以容易的设计一个组合命令。新命令可以容易的加入到系统中。总之一句话就是一些都是为了高内聚，低耦合。我们在学设计模式的时候，我们没有必要一定去纠结这个模式和那个模式

 

 

十二 责任链模式

这个模式我们还是比较熟悉的，因为在以前的狼人杀课程中我们是已经学过的。责任链模式是对象的行为模式。使多个对象都有机会处理请求，从而避免请求的发送者和接收者直接的耦合关系。将这些对象练成一条链，沿着这天链传递请求，直到有一个对象处理它为止。责任链模式强调额是每一个对象其对下家的引用来组成一条链，利用这种方式将发送者和接受者解耦

 

/// <summary>
    /// 抽象处理角色
    /// </summary>
    public abstract class Handler
    {
        protected Handler successor;
        public abstract void HandlerRequest(string condition);
        public Handler getSuccessor()
        {
            return successor;
        }
        public void SetSuccessor(Handler successor)
        {
            this.successor = successor;
        }
    }

    #region 链表子类
    public class ConcreteHandler1 : Handler
    {

        public override void HandlerRequest(string condition)
        {
            //如果是自己的责任，就自己处理；如果不是自己的责任，就负责传给下家处理
            if (condition.Equals("ConcreteHandler1"))
            {
                Console.WriteLine("ConcreteHandler1 handled");
                return;
            }
            else
            {
                Console.WriteLine("ConcreteHandler1 passed");
                getSuccessor().HandlerRequest(condition);
            }
        }
    }

    public class ConcreteHandler2 : Handler
    {

        public override void HandlerRequest(string condition)
        {
            //如果是自己的责任，就自己处理；如果不是自己的责任，就负责传给下家处理
            if (condition.Equals("ConcreteHandler2"))
            {
                Console.WriteLine("ConcreteHandler2 handled");
                return;
            }
            else
            {
                Console.WriteLine("ConcreteHandler2 passed");
                getSuccessor().HandlerRequest(condition);
            }
        }
    }
    #endregion

    public class ConcreteHandlerN : Handler
    {

        public override void HandlerRequest(string condition)
        {
            Console.WriteLine("ConcreateHandlerN handled");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Handler handler1 = new ConcreteHandler1();
            Handler handler2 = new ConcreteHandler2();
            Handler handlern = new ConcreteHandlerN();

            //链起来
            handler1.SetSuccessor(handler2);
            handler2.SetSuccessor(handlern);

            //假设这个请求时ConcreteHandler2的责任
            handler1.HandlerRequest("ConcreteHandler2");
            Console.ReadKey();
        }
    }

　　这种模式首先我们应该创建一个抽象基类，因为这个模式首先是一个链条，这就说明了一点，链条上的所有都是具有不同需求但是基本结构都一样的类，他们应该是继承同一个父亲。在这个基类中我们写出所有的方法，让子类去实现。子类去实现方法HandlerRequest()，这个方法就是链接的关键，其实本质就是在方法中调用另一个类，如果不满足就是调用下一个。用一个更形象一点的说法就是。我们在每一个类中都声明一个空结点变量，handler1.SetSuccessor(handler2);handler2.SetSuccessor(handlern);就像上面的一样，对类中的节点变量进行赋值，我们在 类中使用这个getSuccessor().HandlerRequest(condition);就相当于在自身类中去调用得到结点的方法，多个结点相互调用，这样就像一个链条一样，而其中传递的就是变量，变量在每一个结点类的方法中进行运算如果满足就终止；如果不满足就接着下一个。

十三  观察者模式

观察者模式最重要的就是订阅机制。观察者是订阅者，我只要发出新的消息，然后这个消息就会自动去通知所有的订阅者。

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

namespace 设计模式_观察者模式
{

    public delegate void DeloB(Subject subject, EventArgs e);

    //被观察者抽象类
    public abstract class Subject
    {
        private string _strIntelligence;
        private string _name;
        public string StrIntelligence { get { return _strIntelligence; } set { _strIntelligence = value; } }
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public Subject(string name, string strIntelligence)
        {
            Name = name;
            StrIntelligence = strIntelligence;
        }

        public event DeloB DelPUBGOB;//当OB队友报出敌情时候的事件


        public void PUBGSay()
        {
            DelPUBGOB(this, new EventArgs());
        }
    }

    //观察者抽象类
    public abstract class OBServer
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        abstract protected void Notfied(Subject subject, EventArgs e);
        public OBServer(Subject subject, string name)
        {
            Name = name;
            subject.DelPUBGOB += this.Notfied;
        }
    }

    //活着的队友
    public class TeammateAlive : OBServer
    {
        public TeammateAlive(Subject subject, string name)
            : base(subject, name)
        { }


        protected override void Notfied(Subject subject, EventArgs e)
        {
            Console.WriteLine("{0}:收到", this.Name);
        }
    }

    //死亡的队友
    public class DieTeammates : Subject
    {
        public DieTeammates(string name, string strIntelligence)
            : base(name, strIntelligence)
        {
            Console.WriteLine("{0}:{1}", this.Name, this.StrIntelligence);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            DieTeammates die = new DieTeammates("JackCC", "北偏东75d度发现4个敌人有点慌");
            TeammateAlive team1 = new TeammateAlive(die, "JackDD");
            TeammateAlive team2 = new TeammateAlive(die, "JackFF");
            TeammateAlive team3 = new TeammateAlive(die, "JackGG");
            die.PUBGSay();
            Console.ReadKey();
        }
    }
}