状态模式

假设某人一整天的流程就是“吃饭→工作→睡觉”，并且他要严格按照这个流程来，那也就是说在吃饭状态下，他只能做跟吃饭有关的事情，而不能越界做工作或者睡觉有关的事情，这就涉及到了状态的管理。在写代码的时候，我们常常要根据当前的状态，来决定下一个状态并且确定当前状态下要做什么样的事情。一般来讲，我们会写一系列的if-else if-else if-else语句来实现，但是要是状态非常多的时候，这种代码不仅仅看起来十分长，而且看的人生理上也会有一种厌恶感并且看一点估计忘一点。导致这种臭代码的原因就是，我们一口气在一个函数里面管理了太多种的状态。于是，有人就提出了，能不能让状态自己管理自己。也就有点像我们的行政制度中自治区，我们不再统一地在一个函数里面管理N种状态，而是让某个状态管理它自己本身。

经典的状态管理模式如下图所示

让我来解释一下这幅图的意思，IState依赖于IContext，也就是IContext对应的实体类拥有一个IState类型的字段，在IContext类里面的Request()方法里面调用IState中的Handle方法。我们可以通过改变IContext里面的IState实体类类型来改变状态，从而实现根据不同的状态使用不同的方法。

     下面让我们来段代码说明一下。以下代码模拟数据库的连接、关闭。连接和关闭两个状态分别有两个对应的状态类与之对应。

1、首先我们还是先定义状态的接口，另外定义一个抽象类，用来表示数据库连接类。

/// <summary>
    /// 数据库连接状态
    /// </summary>
    public interface IConnectionState
    {
        void Open();
        void Close();
        void Query();
    }

在定义一个数据库连接对象的抽象基类

abstract class ContextBase
    {

        private IConnectionState connectionState;

        public IConnectionState ConnectionState
        {
            get { return connectionState; }
            set { connectionState = value; }
        }

        public virtual void Open() { this.connectionState.Open(); }
        public virtual void Close() { this.connectionState.Close(); }
        public virtual void Query() { this.connectionState.Query(); }
    }

2、我们再定义两个具体类OpenState、CloseState，实现IConnectionState接口，分别代表数据库开、关两种状态。并且在状态类内部，如OpenState类的内部规定了在Opne状态下，可以执行的操作和不能够执行的操作。

/// <summary>
        /// 打开状态
        /// </summary>
        class OpenState : IConnectionState
        {

            public void Open()
            {
                throw new NotImplementedException("打开状态下，不能再打开数据库连接");
            }

            public void Close()
            {
                //打开状态下，可以关闭数据库连接
            }

            public void Query()
            {
                //打开状态下，可以查询
            }
        }
        /// <summary>
        /// 关闭状态
        /// </summary>
        class CloseState : IConnectionState
        {

            public void Open()
            {
                //关闭状态下可以重新打开连接
            }

            public void Close()
            {
                throw new NotImplementedException("关闭状态下，不能再关闭数据库连接");
            }

            public void Query()
            {
                throw new NotImplementedException("关闭状态下，不能查询数据库");
            }
        }

3、下面我们用一个类来继承抽象类，并进行测试。具体的类实现方式见下方，这里只给出关键函数。

public void ConnectionStateTest()
        {
            ContextBase target = CreateContextBase(); 
            target.ConnectionState = new OpenState();
            try
            {
                target.Open();//执行Open操作，遇到异常，不执行 Assert.IsTrue(false);
                Assert.IsTrue(false);
            }
            catch (Exception ex)
            {
                
            }
            target.Close();//在打开状态下，正常关闭，并执行Assert.IsTrue(false);
            Assert.IsTrue(false);

            target.ConnectionState = new CloseState();
            try
            {
                target.Close();
                Assert.IsTrue(false);
            }
            catch (Exception ex)
            {
            }

            target.Open();
            Assert.IsTrue(false);
        }

从以上代码，我们可以知道，原先需要用讨厌的if-else if-else if-else管理的讨厌的长长的状态管理函数，已经被我们封装在一个个的小状态管理类里面了，并且这些状态管理类可以自己管理自己什么状态应该做什么样的事情。

using BangWorks.PractcalPattern.States.Classic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;

namespace BangWork.PractcalPattern.Concept.InderTest
{


    /// <summary>
    ///这是 ContextBaseTest 的测试类，旨在
    ///包含所有 ContextBaseTest 单元测试
    ///</summary>
    [TestClass()]
    public class ContextBaseTest : ContextBase
    {
        /// <summary>
        /// 打开状态
        /// </summary>
        class OpenState : IConnectionState
        {

            public void Open()
            {
                throw new NotImplementedException("打开状态下，不能再打开数据库连接");
            }

            public void Close()
            {
                //打开状态下，可以关闭数据库连接
            }

            public void Query()
            {
                //打开状态下，可以查询
            }
        }
        /// <summary>
        /// 关闭状态
        /// </summary>
        class CloseState : IConnectionState
        {

            public void Open()
            {
                //关闭状态下可以重新打开连接
            }

            public void Close()
            {
                throw new NotImplementedException("关闭状态下，不能再关闭数据库连接");
            }

            public void Query()
            {
                throw new NotImplementedException("关闭状态下，不能查询数据库");
            }
        }
        private TestContext testContextInstance;

        /// <summary>
        ///获取或设置测试上下文，上下文提供
        ///有关当前测试运行及其功能的信息。
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region 附加测试特性
        // 
        //编写测试时，还可使用以下特性:
        //
        //使用 ClassInitialize 在运行类中的第一个测试前先运行代码
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //使用 ClassCleanup 在运行完类中的所有测试后再运行代码
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //使用 TestInitialize 在运行每个测试前先运行代码
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //使用 TestCleanup 在运行完每个测试后运行代码
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        internal virtual ContextBase CreateContextBase()
        {
            // TODO: 实例化相应的具体类。
            ContextBase target = new ContextBaseTest();
            return target;
        }

        /// <summary>
        ///Close 的测试
        ///</summary>
        [TestMethod()]
        public void CloseTest()
        {
            ContextBase target = CreateContextBase(); // TODO: 初始化为适当的值
            target.Close();
            Assert.Inconclusive("无法验证不返回值的方法。");
        }

        /// <summary>
        ///Open 的测试
        ///</summary>
        [TestMethod()]
        public void OpenTest()
        {
            ContextBase target = CreateContextBase(); // TODO: 初始化为适当的值
            target.Open();
            Assert.Inconclusive("无法验证不返回值的方法。");
        }

        /// <summary>
        ///Query 的测试
        ///</summary>
        [TestMethod()]
        public void QueryTest()
        {
            ContextBase target = CreateContextBase(); // TODO: 初始化为适当的值
            target.Query();
            Assert.Inconclusive("无法验证不返回值的方法。");
        }

        /// <summary>
        ///ConnectionState 的测试
        ///</summary>
        [TestMethod()]
        public void ConnectionStateTest()
        {
            ContextBase target = CreateContextBase(); // TODO: 初始化为适当的值

            target.ConnectionState = new OpenState();
            try
            {
                target.Open();//执行Open操作，遇到异常，不执行 Assert.IsTrue(false);
                Assert.IsTrue(false);
            }
            catch (Exception ex)
            {
                
            }
            target.Close();//在打开状态下，正常关闭，并执行Assert.IsTrue(false);
            Assert.IsTrue(false);

            target.ConnectionState = new CloseState();
            try
            {
                target.Close();
                Assert.IsTrue(false);
            }
            catch (Exception ex)
            {
            }

            target.Open();
            Assert.IsTrue(false);
        }
    }
}