设计模式——状态，C# 语言范例

此范例共4个状态，2种操作，没用interface而是用abstract修饰的class实现。

调用：

            TransServer ts = new TransServer();
            Console.WriteLine(ts.StopServer());
            Console.WriteLine(ts.StartServer());
            Console.WriteLine(ts.StartServer());
            Console.WriteLine(ts.StopServer());
            Console.WriteLine(ts.StopServer());

 

实现：

    internal abstract class State
    {
        internal TransServer transServer;

        public abstract ErrorCode StartServer();
        public abstract ErrorCode StopServer();
    }

    internal class StoppedState : State
    {
        public StoppedState(TransServer ts)
        {
            this.transServer = ts;
        }
        /// <summary>
        /// Stopped --> Init --> Worked or Error or Others.
        /// </summary>
        /// <returns></returns>
        public override ErrorCode StartServer()
        {
            // 下一个状态是initstate
            this.transServer.SetState(this.transServer.GetInitState());
            // do something...

            // finishd...
            // 下一个状态是WorkingState
            this.transServer.SetState(this.transServer.GetWorkingState());
            return ErrorCode.NoError;
        }
        /// <summary>
        /// Do nothing.
        /// </summary>
        /// <returns></returns>
        public override ErrorCode StopServer()
        {
            // it was already stopped!
            return ErrorCode.AlreadyClosed;
        }
    }

    internal class InitState : State
    {
        public InitState(TransServer ts)
        {
            this.transServer = ts;
        }
        /// <summary>
        /// Do nothing.
        /// </summary>
        /// <returns></returns>
        public override ErrorCode StartServer()
        {
            // 正在初始化，不应重复启动。
            return ErrorCode.WaitUntilInitialed;
        }
        /// <summary>
        /// Do nothing.
        /// </summary>
        /// <returns></returns>
        public override ErrorCode StopServer()
        {
            // 初始化可以被终止吗？？
            return ErrorCode.WaitUntilInitialed;
        }
    }

    internal class WorkingState : State
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ts"></param>
        public WorkingState(TransServer ts)
        {
            this.transServer = ts;
        }
        /// <summary>
        /// Do nothing.
        /// </summary>
        /// <returns></returns>
        public override ErrorCode StartServer()
        {
            return ErrorCode.AlreadyStarted;
        }
        /// <summary>
        /// Worked --> Stopped or Error or Others.
        /// </summary>
        /// <returns></returns>
        public override ErrorCode StopServer()
        {
            // do something...

            // finished
            this.transServer.SetState(this.transServer.GetStoppedState());
            return ErrorCode.NoError;
        }
    }

    internal class ErrorState : State
    {
        public ErrorState(TransServer ts)
        {
            this.transServer = ts;
        }

        public override ErrorCode StartServer()
        {
            return ErrorCode.UnknowError;
        }

        public override ErrorCode StopServer()
        {
            return ErrorCode.UnknowError;
        }
    }

    public class TransServer
    {
        State stoppedState;
        internal State GetStoppedState()
        {
            return stoppedState; 
        }
        State initState;
        internal State GetInitState()
        {
            return initState; 
        }
        State workingState;
        internal State GetWorkingState()
        {
            return workingState; 
        }
        State errorState;
        internal State GetErrorState()
        {
            return errorState; 
        }

        State state;
        /// <summary>
        /// 设置当前状态
        /// </summary>
        internal void SetState(State value)
        {
            state = value;
        }
        /// <summary>
        /// 默认构造方法
        /// </summary>
        public TransServer()
        {
            stoppedState = new StoppedState(this);
            initState = new InitState(this);
            workingState = new WorkingState(this);
            errorState = new ErrorState(this);

            state = stoppedState;
        }

        public ErrorCode StartServer()
        {
            ErrorCode rv = state.StartServer();
            return rv;
        }

        public ErrorCode StopServer()
        {
            ErrorCode rv = state.StopServer();
            return rv;
        }
    }

 

    /// <summary>
    /// 错误码
    /// </summary>
    public enum ErrorCode
    {
        NoError = 0,
        AlreadyClosed,
        WaitUntilInitialed,
        AlreadyStarted,
        UnknowError,
    }