設計模式二

接設計模式一

固然這個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();
        }
    }
}