设计模式二

接设计模式一

固然这个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();
        }
    }
}