本文的概念性內容來自深入淺出設計模式一書項目需求這是一個糖果機的需求圖. 它有四種狀態, 分別是圖中的四個圓圈: No Quarter: 無硬幣 Has Quater 有硬幣 Gumball Sold 糖果賣出 Out of Gumball 沒有糖果了這個圖很像一個狀態圖. 每個圓圈就是一個狀 ...

本文的概念性內容來自深入淺出設計模式一書

項目需求

這是一個糖果機的需求圖.

它有四種狀態, 分別是圖中的四個圓圈:

No Quarter: 無硬幣
Has Quater 有硬幣
Gumball Sold 糖果賣出
Out of Gumball 沒有糖果了

這個圖很像一個狀態圖. 每個圓圈就是一個狀態, 每個帶箭頭的線就是狀態的轉換.

這個需求用文字描述就是: 糖果機在沒投硬幣的時候, 可以投硬幣, 投完硬幣, 搬動手柄, 糖果就會出來, 如果糖果機里沒有糖果了, 那麼就無法再賣糖果了.

初步設計

這個需求看起來還是蠻簡單的, 我想可以這樣來實現:

1. 整理好所有的狀態, 一共有4個:

2. 創建一個實例變數來保存當前的狀態, 併為每個狀態定義一個值:

3. 整理好系統中可能發生的動作:

4. 創建一個類作為狀態機, 針對每一個動作, 我們創建一個方法, 在方法里我們使用條件語句來決定在每個狀態中該行為是否合理. 例如, 投入硬幣後, 我們可能需要下麵這個方法:

註意: 最後一個if中, 有改變狀態的動作(如果之前的狀態是沒有硬幣, 那麼投入硬幣後, 狀態應改為有硬幣).

下麵來實現這個狀態機:

代碼量還是不小啊, 這裡面主要做的就是在每個動作方法里, 判斷各種狀態, 如何合理就改變狀態.

運行一下:

結果:

看起來一切都OK了, 直到:

需求變更

糖果機老闆說, 我想買糖果變成一個游戲, 投硬幣買糖果的人中的10%在搬動手柄後將會得到兩個糖果而不是一個.

現在的狀態開始有點亂了:

隨著需求的變化, 我們設計會導致越來越多的bug...

回想一下設計原則: "把變化的部分封裝起來" 和 "儘量使用組合". 我們可以把每個狀態的行為放到它自己的類裡面, 然後每個動作只需要實現自己狀態下的動作即可. 而且也許糖果機可以使用狀態對象來委托表示自己當前的狀態.

重新設計

這次我們就把狀態的行為封裝到各個狀態對象裡面, 併在動作發生的時候委托到當前的狀態.

1. 首先, 定義一個狀態介面, 這個介面包含糖果機的每個動作

2. 針對每種狀態, 實現一個具體的狀態類. 這些類將負責糖果機在改狀態下的行為.

3. 最後, 去掉那些條件判斷代碼, 把這些工作委托給狀態類.

上面要實現的就是狀態模式 (State Pattern).

把一個狀態所有的行為放到一個類裡面, 這樣, 就實現了本地化並且便於修改和理解.

設計類圖:

這裡我們使用狀態類來代替初版設計中的數值.

當然別忘了這個狀態:

現在我直接使用C#實現這些狀態:

狀態介面:

namespace StatePattern.Abstractions
{
    public interface IState
    {
        void InjectQuarter();
        void EjectQuarter();
        void TurnCrank();
        void Dispense();
    }
}

五個狀態, 有硬幣:

using System;
using StatePattern.Abstractions;
using StatePattern.Machines;

namespace StatePattern.States
{
    public class HasQuarterState : IState
    {
        private readonly GumballMachine _gumballMachine;
        private readonly Random _random = new Random();

        public HasQuarterState(GumballMachine gumballMachine)
        {
            _gumballMachine = gumballMachine;
        }

        public void InjectQuarter()
        {
            Console.WriteLine("You can’t insert another quarter");
        }

        public void EjectQuarter()
        {
            Console.WriteLine("Quarter returned");
            _gumballMachine.State = _gumballMachine.NoQuarterState;
        }

        public void TurnCrank()
        {
            Console.WriteLine("You turned...");
            var winner = _random.Next(0, 10);
            if (winner == 0 && _gumballMachine.Count > 1)
            {
                _gumballMachine.State = _gumballMachine.WinnerState;
            }
            else
            {
                _gumballMachine.State = _gumballMachine.SoldState;
            }
        }

        public void Dispense()
        {
            Console.WriteLine("No gumball dispensed");
        }

        public override string ToString()
        {
            return "just being inserted with a quarter";
        }
    }
}

無硬幣:

using System;
using StatePattern.Abstractions;
using StatePattern.Machines;

namespace StatePattern.States
{
    public class NoQuarterState: IState
    {
        private readonly GumballMachine _gumballMachine;

        public NoQuarterState(GumballMachine gumballMachine)
        {
            _gumballMachine = gumballMachine;
        }

        public void InjectQuarter()
        {
            Console.WriteLine("You inserted a quarter");
            _gumballMachine.State = _gumballMachine.HasQuarterState;
        }

        public void EjectQuarter()
        {
            Console.WriteLine("You havn't inserted a quarter");
        }

        public void TurnCrank()
        {
            Console.WriteLine("You turned, but there is no quarter");
        }

        public void Dispense()
        {
            Console.WriteLine("You need to pay first");
        }

        public override string ToString()
        {
            return "is Waiting for quarter";
        }
    }
}

View Code

賣光了:

using System;
using StatePattern.Abstractions;
using StatePattern.Machines;

namespace StatePattern.States
{
    public class SoldOutState: IState
    {
        private readonly GumballMachine _gumballMachine;

        public SoldOutState(GumballMachine gumballMachine)
        {
            _gumballMachine = gumballMachine;
        }

        public void InjectQuarter()
        {
            Console.WriteLine("You can’t insert a quarter, the machine is sold out");
        }

        public void EjectQuarter()
        {
            Console.WriteLine("You can’t eject, you haven’t inserted a quarter yet");
        }

        public void TurnCrank()
        {
            Console.WriteLine("You turned, but there are no gumballs");
        }

        public void Dispense()
        {
            Console.WriteLine("No gumball dispensed");
        }

        public override string ToString()
        {
            return "is sold out";
        }
    }
}

View Code

剛剛賣出糖果:

using System;
using StatePattern.Abstractions;
using StatePattern.Machines;

namespace StatePattern.States
{
    public class SoldState : IState
    {
        private readonly GumballMachine _gumballMachine;

        public SoldState(GumballMachine gumballMachine)
        {
            _gumballMachine = gumballMachine;
        }

        public void InjectQuarter()
        {
            Console.WriteLine("Please wait, we’re already giving you a gumball");
        }

        public void EjectQuarter()
        {
            Console.WriteLine("Sorry, you already turned the crank");
        }

        public void TurnCrank()
        {
            Console.WriteLine("Turning twice doesn’t get you another gumball!");
        }

        public void Dispense()
        {
            _gumballMachine.ReleaseBall();
            if (_gumballMachine.Count > 0)
            {
                _gumballMachine.State = _gumballMachine.NoQuarterState;
            }
            else
            {
                Console.WriteLine("Oops, out of gumballs!");
                _gumballMachine.State = _gumballMachine.SoldOutState;
            }
        }

        public override string ToString()
        {
            return "just sold a gumball";
        }
    }
}

View Code

中獎了:

using System;
using StatePattern.Abstractions;
using StatePattern.Machines;

namespace StatePattern.States
{
    public class WinnerState: IState
    {
        private readonly GumballMachine _gumballMachine;

        public WinnerState(GumballMachine gumballMachine)
        {
            _gumballMachine = gumballMachine;
        }

        public void InjectQuarter()
        {
            Console.WriteLine("Please wait, we’re already giving you a gumball");
        }

        public void EjectQuarter()
        {
            Console.WriteLine("Sorry, you already turned the crank");
        }

        public void TurnCrank()
        {
            Console.WriteLine("Turning twice doesn’t get you another gumball!");
        }

        public void Dispense()
        {
            Console.WriteLine("YOU'RE A WINNER! You get two balls for you quarter");
            _gumballMachine.ReleaseBall();
            if (_gumballMachine.Count == 0)
            {
                _gumballMachine.State = _gumballMachine.SoldOutState;
            }
            else
            {
                _gumballMachine.ReleaseBall();
                if (_gumballMachine.Count > 0)
                {
                    _gumballMachine.State = _gumballMachine.NoQuarterState;
                }
                else
                {
                    Console.WriteLine("Oops, out of gumballs!");
                    _gumballMachine.State = _gumballMachine.SoldOutState;
                }
            }
        }

        public override string ToString()
        {
            return "just sold 2 gumballs";
        }
    }
}

View Code

糖果機:

using System;
using StatePattern.Abstractions;
using StatePattern.States;

namespace StatePattern.Machines
{
    public class GumballMachine
    {
        public IState SoldOutState { get; set; }
        public IState NoQuarterState { get; set; }
        public IState HasQuarterState { get; set; }
        public IState SoldState { get; set; }
        public IState WinnerState { get; set; }
        public IState State { get; set; }
        public int Count { get; set; }

        public GumballMachine(int numberOfGumballs)
        {
            SoldState = new SoldState(this);
            NoQuarterState = new NoQuarterState(this);
            HasQuarterState = new HasQuarterState(this);
            SoldOutState = new SoldOutState(this);
            WinnerState = new WinnerState(this);

            Count = numberOfGumballs;
            if (Count > 0)
            {
                State = NoQuarterState;
            }
        }

        public void InjectQuarter()
        {
            State.InjectQuarter();
        }

        public void EjectQuarter()
        {
            State.EjectQuarter();
        }

        public void TurnCrank()
        {
            State.TurnCrank();
            State.Dispense();
        }

        public void ReleaseBall()
        {
            Console.WriteLine("A gumball comes rolling out the slot...");
            if (Count != 0)
            {
                Count--;
            }
        }

        public void Refill(int count)
        {
            Count += count;
            State = NoQuarterState;
        }

        public override string ToString()
        {
            return $"Mighty Gumball, Inc.\nC#-enabled Standing Gumball Model #2018\nInventory: {Count} gumballs\nThe machine {State} ";
        }
    }
}

註意糖果機裡面的狀態使用的是對象而不是原來的數值.

運行:

using System;
using StatePattern.Machines;

namespace StatePattern
{
    class Program
    {
        static void Main(string[] args)
        {
            var originalColor = Console.ForegroundColor;

            var machine = new GumballMachine(5);
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.WriteLine(machine);

            Console.ForegroundColor = originalColor;
            Console.WriteLine();
            machine.InjectQuarter();
            machine.TurnCrank();
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.WriteLine(machine);

            Console.ForegroundColor = originalColor;
            Console.WriteLine();
            machine.InjectQuarter();
            machine.TurnCrank();
            machine.InjectQuarter();
            machine.TurnCrank();
            machine.InjectQuarter();
            machine.TurnCrank();
            machine.InjectQuarter();
            machine.TurnCrank();
            Console.ForegroundColor = ConsoleColor.Blue;
            Console.WriteLine(machine);

            Console.ReadKey();
        }
    }
}

我們做了什麼?

我們修改了設計的結構, 但是功能是一樣的:

把每個狀態的行為本地化到它自己的類裡面了
移除了所有狀態判斷代碼, 他們也很難維護.
對每個狀態的修改關閉, 但是讓糖果機仍然可以擴展 (添加WINNER 狀態)
創建了一個與需求圖幾乎完美對應的代碼庫和類結構, 便於理解.

狀態模式定義

狀態模式允許一個對象在內部狀態改變的時候可以修改它自己的行為. 對象似乎修改了它的類.

第二句可以這樣理解:

從客戶的觀點, 如果一個你使用的對象可以完全改變它的行為, 那麼這個對象看起來就像是從別的類初始化出來的一樣 (變了一個類). 而實際上呢, 你使用的是組合的方式來實現變類的效果, 具體到我們的項目就是引用不同的狀態對象.

類圖:

Context(上下文環境)就是擁有很多內部狀態的類, 糖果機.

每當request()發生在Context上的時候, 它就被委托給了當時的狀態對象. 右邊就是各種狀態對象.

比較一下策略模式和狀態模式

這兩個模式錶面上看起來可能有點像, 但是實際上它們的目的是不同的.

狀態模式下, 我們把一套行為封裝在狀態對象里; 任何要給時刻, Context總是委托工作給其中的一個對象. 隨著時間的變化, Context的當前狀態對象也發生變化, 所以Context的行為也隨之變化. 客戶對狀態對象知道的很少.

策略模式下, 客戶要指定策略對象和Context組合. 該模式允許在運行時靈活的改變策略, 通常會有一個最適合當時環境的策略.

總體來說,

策略模式是對繼承的靈活替換. 使用繼承來定義類的行為, 當你需要改變的時候, 這個行為還會在的, 使用策略模式可是組合不同的對象來改變行為.

狀態模式則是一大堆條件判斷的代替者, 把行為封裝在狀態對象里, 就可以簡單的通過切換狀態對象來改變Context的行為.

其他問題

Q: 總是由具體的狀態對象來決定狀態的走向嗎?

A: 也不是, 可以用Context決定狀態的走向.

Q: 客戶直接訪問狀態嗎?

A: 客戶不直接改變狀態.

Q: 如果Context有很多實例, 那麼可以共用狀態對象嗎?

A: 可以, 這個也經常發生. 但這要求你的狀態對象不可以保存它們的內部狀態, 否則每個Context都需要一個單獨的實例.

Q: 這麼設計看起來類很多啊!

A: 是啊, 但是可以讓對客戶可見的類的個數很少, 這個數量才重要

Q: 可以使用抽象類來代替State介面嗎?

A: 可以, 如果需要一些公共方法的話.

總結

今天的比較簡單, 只有這一個概念:

狀態模式允許一個對象在內部狀態改變的時候可以修改它自己的行為. 對象似乎修改了它的類.

該系列的源碼在: https://github.com/solenovex/Head-First-Design-Patterns-in-CSharp

使用C# (.NET Core) 實現狀態設計模式 (State Pattern)

項目需求

初步設計

需求變更

重新設計

我們做了什麼?

狀態模式定義

比較一下策略模式和狀態模式

其他問題

總結