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

最新推荐文章于 2025-08-12 14:27:48 发布

erwintao

最新推荐文章于 2025-08-12 14:27:48 发布

阅读量404

点赞数

CC 4.0 BY-SA版权

分类专栏： .net 文章标签： c# C# 状态范例设计模式

本文链接：https://blog.youkuaiyun.com/erwintao/article/details/8191612

.net 专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一个使用抽象类实现的状态机，通过不同的状态来控制服务器的启动和停止操作，包括停止、初始化、工作和错误状态，并详细解释了每个状态的操作逻辑。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

此范例共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,
    }