登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›推荐一款高性能状态机管理解决方案

推荐一款高性能状态机管理解决方案

啦汇 2025-8-15 21:02:46
在实际软件开发中，尤其是工业软件，每一款设备都有复杂的状态以及状态之间的切换的功能需求，在这种情况下，如何管理状态以及状态之间切换，和对应状态下的功能控制，成为非常重要的一个问题。如果处理不好，那这种繁复的状态将成为“像面条一样”缠绕耦合，一团乱麻，真的就是“剪不断，理还乱”。那如何解决这个问题呢？今天我们以一篇简单的小例子，简述如何通过Stateless组件，完成状态的管理和触发，仅供学习分享使用，如有不足之处，还请指正。
 
什么是状态模式？

 
关于状态模式和状态机，如下所示：

  • 状态模式："允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它所属的类 "。(State Pattern: "Allow an object to alter its behavior when its internal state changes. The object will appear to change its class ".)。对于这个定义，有点抽象，变通理解一下可以这么理解：状态拥有者将变更行为委托给状态对象，状态拥有者本身只拥有状态(当然也可以抛弃状态对象)，状态对象履行变更职责。
  • 状态机："依照指定的状态流程图，根据当前执行的动作，将当前状态按照预定的条件变更到新的状态 "。状态机有4个要素，即现态、条件、动作、次态。其中，现态和条件是“因”， 动作和次态是“果”。




    • 现态 - 是指当前对象的状态
    • 条件 - 当一个条件满足时，当前对象会触发一个动作
    • 动作 - 条件满足之后，执行的动作
    • 次态 - 条件满足之后，当前对象的新状态。次态是相对现态而言的，次态一旦触发，就变成了现态



  • 状态迁移图："在UML建模中，常常可见，用来描述一个特定的对象所有可能的状态,以及由于各种事件的发生而引起的状态之间的转移和变化，也是配置状态机按照何种行径的前提 "。
 
什么是Stateless?

 
Stateless是一个轻量级、高性能的状态机库，它基于.Net Standard实现，在.Net Framework和.Net Core项目中都可以使用，能够轻松地帮助我们实现状态转换的逻辑。
github：https://github.com/dotnet-state-machine/stateless
1.png

 
实例场景说明

 
本文主要通过Stateless组件实现如下一个状态的管理和触发，
当前有一个设备软件，它拥有如下几个状态(State)：

  • Idle状态，表示当前没有运行任务，处于空闲状态。
  • Running状态，表示当前正在工作，处于运行状态。
  • Malfunction状态，表示当前有异常，出于故障状态。
  • Recovery状态，表示经过维修，从故障中恢复了，处于修复状态。
它拥有触发动作(Trigger)：

  • Work，表示当前开始工作，它可以由Idle状态进入，也可以从Recovery状态进入，程序会进入Running状态。
  • Fatal，表示遇到异常，它只可以由Running状态进入，程序会进入Malfunction状态。
  • Repair，表示修复异常，它只可以由Malfunction状态进入，程序会进入Recovery状态。
  • Finish，表示完成，它可以由Running状态进入，也可以由Recovery状态进入，程序会进入Idle状态。
上述状态（State）和触发动作（Trigger）以及之间的流转，如下图所示：
2.png

 
创建项目

 
为了演示状态变化，我们创建一个WinForm应用程序“Okcoder.Stateless.WinTool”和一个公共库“Okcoder.Stateless.Common”，如下所示：
3.png

 
安装Stateless组件

 
在Visual Studio 2022开发工具中，可以通过Nuget包管理器进行安装。在解决方案右键，打开右键菜单，然后点击“管理解决方案的Nuget程序包”在打开的Nuget包解决方案，搜索Stateless，然后安装即可。当前最新版为v5.18.0，如下所示：
4.png

 
定义状态和触发器

 
状态机管理状态的变化和触发事件，所以定义状态和触发器，它们是枚举类型，根据实例场景说明进行定义ToolState如下所示：
  1. namespace Okcoder.Stateless.Common
  2. {
  3.     /// <summary>
  4.     /// 工具状态
  5.     /// </summary>
  6.     public enum ToolState
  7.     {
  8.         Idle=0, //空闲状态
  9.         Running=1, //运行状态
  10.         Malfunction = 2, // 故障状态
  11.         Recovery=3, //已恢复状态
  12.     }
  13. }
复制代码
ToolTrigger定义如下所示：
  1. namespace Okcoder.Stateless.Common
  2. {
  3.     public enum ToolTrigger
  4.     {
  5.         Work = 0, // 开始运转
  6.         Fatal = 1, // 出异常
  7.         Finish = 2, // 完成
  8.         Repair=3, //维修
  9.     }
  10. }
复制代码
 
定义接口

 
定义IToolStateService接口，它表示状态机所具备的能力，如触发动作，状态判断，状态机导出DotGraph等，如下所示：
  1. namespace Okcoder.Stateless.Common
  2. {
  3.     /// <summary>
  4.     /// 状态机接口
  5.     /// </summary>
  6.     public interface IToolStateService
  7.     {
  8.         /// <summary>
  9.         /// 初始化状态
  10.         /// </summary>
  11.         void Init();
  13.         /// <summary>
  14.         /// 开始工作
  15.         /// </summary>
  16.         /// <returns></returns>
  17.         ToolResult Work();
  19.         /// <summary>
  20.         /// 遇到严重错误
  21.         /// </summary>
  22.         /// <returns></returns>
  23.         ToolResult Fatal();
  25.         /// <summary>
  26.         /// 维修
  27.         /// </summary>
  28.         /// <returns></returns>
  29.         ToolResult Repair();
  31.         /// <summary>
  32.         /// 完成
  33.         /// </summary>
  34.         /// <returns></returns>
  35.         ToolResult Finish();
  37.         /// <summary>
  38.         /// 是否是Idle状态
  39.         /// </summary>
  40.         /// <returns></returns>
  41.         bool IsIdleState();
  43.         /// <summary>
  44.         /// 是否运行状态
  45.         /// </summary>
  46.         /// <returns></returns>
  47.         bool IsRunningState();
  49.         /// <summary>
  50.         /// 是否故障状态
  51.         /// </summary>
  52.         /// <returns></returns>
  53.         bool IsMalfunctionState();
  55.         /// <summary>
  56.         /// 是否恢复状态
  57.         /// </summary>
  58.         /// <returns></returns>
  59.         bool IsRecoveryState();
  61.         /// <summary>
  62.         /// 获取当前状态
  63.         /// </summary>
  64.         /// <returns></returns>
  65.         ToolState GetToolState();
  67.         /// <summary>
  68.         /// 状态机导出DotGraph
  69.         /// </summary>
  70.         /// <param name="path"></param>
  71.         void ExportDotGraph(string path);
  72.     }
  73. }
复制代码
定义设备工作IToolWorkService接口，它表示设备运行工作，执行操作。如下所示：
  1. namespace Okcoder.Stateless.Common
  2. {
  3.     /// <summary>
  4.     /// 设备工作流程接口
  5.     /// </summary>
  6.     public interface IToolWorkService
  7.     {
  8.         /// <summary>
  9.         /// 是否制造故障
  10.         /// </summary>
  11.         bool IsMakeFatal { get; set; }
  13.         /// <summary>
  14.         /// 开始工作
  15.         /// </summary>
  16.         void DoWork();
  18.         /// <summary>
  19.         /// 维修
  20.         /// </summary>
  21.         void Repair();
  22.     }
  23. }
复制代码
 
实现服务

 
实现状态机服务ToolStateService，它主要应用Stateless组件实现状态的管理和触发动作切换状态，如下所示：
  1. using Stateless;
  2. using Stateless.Graph;
  3. using System.Text;
  5. namespace Okcoder.Stateless.Common
  6. {
  7.         /// <summary>
  8.         /// 状态机服务
  9.         /// </summary>
  10.         public class ToolStateService : IToolStateService
  11.         {
  12.                 private Action<ToolState> toolAction;// 动作
  14.         private StateMachine<ToolState, ToolTrigger> toolStateMachine;
  16.                 public ToolStateService(Action<ToolState> toolAction)
  17.                 {
  18.                         //定义状态机
  19.                         this.toolStateMachine = new StateMachine<ToolState, ToolTrigger>(ToolState.Idle);
  20.                         //配置每一个状态所允许的动作
  21.                         this.toolStateMachine.Configure(ToolState.Idle).Permit(ToolTrigger.Work, ToolState.Running);
  22.                         this.toolStateMachine.Configure(ToolState.Running).Permit(ToolTrigger.Fatal, ToolState.Malfunction).Permit(ToolTrigger.Finish, ToolState.Idle);
  23.                         this.toolStateMachine.Configure(ToolState.Malfunction).Permit(ToolTrigger.Repair, ToolState.Recovery);
  24.                         this.toolStateMachine.Configure(ToolState.Recovery).Permit(ToolTrigger.Work, ToolState.Running).Permit(ToolTrigger.Finish, ToolState.Idle);
  25.                         this.toolAction = toolAction;
  26.                        
  27.                 }
  29.                 /// <summary>
  30.                 /// 初始化状态
  31.                 /// </summary>
  32.                 public void Init()
  33.                 {
  34.                         this.toolAction(ToolState.Idle);
  35.                 }
  37.                 /// <summary>
  38.                 /// 响应触发动作
  39.                 /// </summary>
  40.                 /// <param name="trigger"></param>
  41.                 private ToolResult Fire(ToolTrigger trigger)
  42.                 {
  43.                         ToolResult toolResult = new ToolResult();
  44.                         try
  45.                         {
  46.                                 if (!this.toolStateMachine.CanFire(trigger))
  47.                                 {
  48.                                         toolResult.IsOk = false;
  49.                                         toolResult.Desc = $"当前状态是{this.toolStateMachine.State},不允许执行{trigger}操作";
  50.                                 }
  51.                                 else
  52.                                 {
  53.                                         this.toolStateMachine.Fire(trigger);
  54.                                         toolResult.IsOk = true;
  55.                                         toolResult.Desc = "Ok";
  56.                                         DoAction();
  58.                 }
  59.                         }
  60.                         catch (InvalidOperationException ex)
  61.                         {
  62.                                 toolResult.IsOk = false;
  63.                                 toolResult.Desc = ex.Message;
  64.                         }
  65.                         return toolResult;
  66.                 }
  68.                 /// <summary>
  69.                 /// 判断是否在状态
  70.                 /// </summary>
  71.                 /// <param name="toolState"></param>
  72.                 /// <returns></returns>
  73.                 private bool IsInState(ToolState toolState)
  74.                 {
  75.                         return this.toolStateMachine.IsInState(toolState);
  76.                 }
  78.                 /// <summary>
  79.                 /// 事件通知
  80.                 /// </summary>
  81.                 private void DoAction()
  82.                 {
  83.                         if (this.toolAction != null)
  84.                         {
  85.                                 this.toolAction(this.toolStateMachine.State);
  86.                         }
  87.                 }
  89.                 /// <summary>
  90.                 /// 开始工作
  91.                 /// </summary>
  92.                 public ToolResult Work()
  93.                 {
  94.                         return this.Fire(ToolTrigger.Work);
  95.                 }
  97.                 /// <summary>
  98.                 /// 遇到严重错误
  99.                 /// </summary>
  100.                 public ToolResult Fatal()
  101.                 {
  102.                         return this.Fire(ToolTrigger.Fatal);
  103.                 }
  105.                 /// <summary>
  106.                 /// 维修
  107.                 /// </summary>
  108.                 public ToolResult Repair()
  109.                 {
  110.                         return this.Fire(ToolTrigger.Repair);
  111.                 }
  113.                 /// <summary>
  114.                 /// 完成
  115.                 /// </summary>
  116.                 public ToolResult Finish()
  117.                 {
  118.                         return this.Fire(ToolTrigger.Finish);
  119.                 }
  121.                 /// <summary>
  122.                 /// 是否是Idle状态
  123.                 /// </summary>
  124.                 /// <returns></returns>
  125.                 public bool IsIdleState()
  126.                 {
  127.                         return this.IsInState(ToolState.Idle);
  128.                 }
  130.                 /// <summary>
  131.                 /// 是否运行状态
  132.                 /// </summary>
  133.                 /// <returns></returns>
  134.                 public bool IsRunningState()
  135.                 {
  136.                         return this.IsInState(ToolState.Running);
  137.                 }
  139.                 /// <summary>
  140.                 /// 是否故障状态
  141.                 /// </summary>
  142.                 /// <returns></returns>
  143.                 public bool IsMalfunctionState()
  144.                 {
  145.                         return this.IsInState(ToolState.Malfunction);
  146.                 }
  148.                 /// <summary>
  149.                 /// 是否恢复状态
  150.                 /// </summary>
  151.                 /// <returns></returns>
  152.                 public bool IsRecoveryState()
  153.                 {
  154.                         return this.IsInState(ToolState.Recovery);
  155.                 }
  157.                 public ToolState GetToolState()
  158.                 {
  159.                         return this.toolStateMachine.State;
  160.                 }
  162.                 /// <summary>
  163.                 /// 状态机导出DotGraph
  164.                 /// </summary>
  165.                 /// <param name="path"></param>
  166.                 public void ExportDotGraph(string path)
  167.                 {
  168.                         var info = this.toolStateMachine.GetInfo();
  169.                         string graph = UmlDotGraph.Format(info);
  170.                         using (FileStream stream = File.OpenWrite(path))
  171.                         {
  172.                                 using (StreamWriter writer = new StreamWriter(stream))
  173.                                 {
  174.                                         writer.Write(graph);
  175.                                         writer.Close();
  176.                                 }
  177.                                 stream.Close();
  178.                         }
  179.                 }
  181.         }
  182. }
复制代码
其中StateMachine是状态机的核心类，它有两个泛型参数，分别表示ToolState和ToolTrigger，构造函数中传入初始状态，在本示例中，传入ToolStage.Idle即可。
StateMachine通过对象实例的Configure方法配置允许的状态及通过Permit方法配置当前状态允许通过Trigger转换的新的状态。
配置完成后，通过Fire方法响应触发动作，通过IsInState方法判断当前是否处于指定的状态。
在状态机服务类构造函数中，接收一个Action的委托方法，用于输出状态到UI层，当然也可以采用其他事件订阅发布的解耦方法。
其中ToolResult返回值，表示状态机执行后返回的接口，它是一个类，如下所示：
  1. namespace Okcoder.Stateless.Common
  2. {
  3.     /// <summary>
  4.     /// 工具执行结果
  5.     /// </summary>
  6.     public class ToolResult
  7.     {
  8.         public bool IsOk { get; set; }
  10.         public string Desc { get; set; }
  11.     }
  12. }
复制代码
 
 实现工作服务ToolWorkService，主要是模拟设备工具运行，当开始工作时，输出文本到UI页面上，如果有异常，则停止；若无异常，则运行完成，如下所示：
  1. namespace Okcoder.Stateless.Common
  2. {
  3.     /// <summary>
  4.     /// 设备工作服务
  5.     /// </summary>
  6.     public class ToolWorkService:IToolWorkService
  7.     {
  8.         private Action<string> _progress;
  10.         private IToolStateService _toolStateService;
  12.         private bool _isMakeFatal=false;
  14.         public bool IsMakeFatal
  15.         {
  16.             get { return _isMakeFatal; }
  17.             set { _isMakeFatal = value; }
  18.         }
  20.         public ToolWorkService(IToolStateService toolStateService, Action<string> progress,bool isMakeFatal=false)
  21.         {
  22.             _progress = progress;
  23.             _toolStateService = toolStateService;
  24.             _isMakeFatal = isMakeFatal;
  25.         }
  27.         public void DoWork()
  28.         {
  29.             BeginWork();
  30.             Work();
  31.             Finish();
  32.         }
  34.         public void Repair()
  35.         {
  36.             var result = this._toolStateService.Repair();
  37.             if (result.IsOk)
  38.             {
  39.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 故障被修好了");
  40.             }
  41.             else
  42.             {
  43.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 故障没有被修好");
  44.             }
  45.             
  46.         }
  48.         /// <summary>
  49.         /// 开始工作
  50.         /// </summary>
  51.         private void BeginWork()
  52.         {
  53.             var result = this._toolStateService.Work();
  54.             if (result.IsOk)
  55.             {
  56.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始工作了");
  57.             }
  58.             else
  59.             {
  60.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始工作失败了");
  61.             }
  62.             
  63.         }
  65.         /// <summary>
  66.         /// 工作过程
  67.         /// </summary>
  68.         private void Work()
  69.         {
  70.             for (int i = 0; i < 30; i++)
  71.             {
  72.                 if (_isMakeFatal)
  73.                 {
  74.                     if (i > 10)
  75.                     {
  76.                         MarkFatal();// 运行一段时间，报故障
  77.                         break;
  78.                     }
  79.                 }
  80.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 当前正在工作 - {i}");
  81.                 Thread.Sleep(300);
  82.             }
  83.         }
  85.         /// <summary>
  86.         /// 完成工作
  87.         /// </summary>
  88.         private void Finish()
  89.         {
  90.             var result = this._toolStateService.Finish();
  91.             if (result.IsOk)
  92.             {
  93.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 完成工作了");
  94.             }
  95.             else
  96.             {
  97.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} {result.Desc}");
  98.             }
  99.         }
  101.         private void MarkFatal()
  102.         {
  103.             var result = this._toolStateService.Fatal();
  104.             if (result.IsOk)
  105.             {
  106.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 哎呀，出错了呢？");
  107.             }
  108.             else
  109.             {
  110.                 OutPutInfo($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 制造故障失败");
  111.             }
  112.             
  113.         }
  115.         /// <summary>
  116.         /// 输出信息
  117.         /// </summary>
  118.         /// <param name="msg"></param>
  119.         private void OutPutInfo(string msg)
  120.         {
  121.             if (_progress != null)
  122.             {
  123.                 _progress(msg);
  124.             }
  125.         }
  126.     }
  127. }
复制代码
其中构造函数接收一个Action的委托，用于向UI输出信息，当然也可以是其他的形式。
 
UI调用

 
在Okcoder.Stateless.WinTool项目中，创建FrmMain页面，在构造函数中定义IToolStateService和IToolWorkService的对象实例，并且在Load方法中初始化。
当用户点击Work时，开始调用IToolWorkService的Work方法，在执行过程中，会输出信息到UI页面。
在UI页面有一个复选框，用于设置是否触发异常，可以模拟有异常的场景，如果出现异常，则点击Repair按钮进行修复。
在执行各个动作时，可以看到不同的状态变化。如下所示：
  1. using Okcoder.Stateless.Common;
  3. namespace Okcoder.Stateless.WinTool
  4. {
  5.     public partial class FrmMain : Form
  6.     {
  7.         private IToolStateService toolStateService;
  9.         private IToolWorkService toolWorkService;
  11.         public FrmMain()
  12.         {
  13.             InitializeComponent();
  14.             this.toolStateService = new ToolStateService(ToolStateAction);
  15.             this.toolWorkService = new ToolWorkService(toolStateService, ToolWorkProcessAction, this.chkFatal.Checked);
  16.         }
  18.         private void FrmMain_Load(object sender, EventArgs e)
  19.         {
  20.             this.toolStateService.Init();
  21.         }
  23.         /// <summary>
  24.         /// 开始工作
  25.         /// </summary>
  26.         /// <param name="sender"></param>
  27.         /// <param name="e"></param>
  28.         private void btnWork_Click(object sender, EventArgs e)
  29.         {
  30.             this.txtInfo.Text = string.Empty;
  31.             this.toolWorkService.IsMakeFatal = this.chkFatal.Checked;
  32.             Task.Run(() =>
  33.             {
  34.                 this.toolWorkService.DoWork();
  35.             });
  36.         }
  38.         /// <summary>
  39.         /// 维修
  40.         /// </summary>
  41.         /// <param name="sender"></param>
  42.         /// <param name="e"></param>
  43.         private void btnRepair_Click(object sender, EventArgs e)
  44.         {
  45.             this.toolWorkService.Repair();
  46.         }
  48.         /// <summary>
  49.         /// 导出状态机DotGraph文件
  50.         /// </summary>
  51.         /// <param name="sender"></param>
  52.         /// <param name="e"></param>
  53.         private void btnExport_Click(object sender, EventArgs e)
  54.         {
  55.             SaveFileDialog saveFileDialog = new SaveFileDialog();
  56.             saveFileDialog.DefaultExt = "txt";
  57.             saveFileDialog.Filter = "txt文件|*.txt";
  58.             saveFileDialog.FileName = "Okcoder.txt";
  59.             if (saveFileDialog.ShowDialog() == DialogResult.OK)
  60.             {
  61.                 var filePath = saveFileDialog.FileName;
  62.                 this.toolStateService.ExportDotGraph(filePath);
  63.                 MessageBox.Show("导出成功");
  64.             }
  65.         }
  67.         private void ToolStateAction(ToolState toolState)
  68.         {
  69.             this.Invoke(() =>
  70.             {
  71.                 this.lblState.Text = toolState.ToString();
  72.                 switch (toolState)
  73.                 {
  74.                     case ToolState.Idle:
  75.                     case ToolState.Recovery:
  76.                         this.btnWork.Enabled = true;
  77.                         this.btnRepair.Enabled = false;
  78.                         this.lblState.ForeColor = Color.Black;
  79.                         break;
  80.                     case ToolState.Running:
  81.                         this.btnWork.Enabled = false;
  82.                         this.btnRepair.Enabled = false;
  83.                         this.lblState.ForeColor = Color.Goldenrod;
  84.                         break;
  85.                     case ToolState.Malfunction:
  86.                         this.btnWork.Enabled = false;
  87.                         this.btnRepair.Enabled = true;
  88.                         this.lblState.ForeColor = Color.Red;
  89.                         break;
  90.                 }
  91.                 this.Refresh();
  92.             });
  93.         }
  95.         private void ToolWorkProcessAction(string msg)
  96.         {
  97.             this.Invoke(() =>
  98.             {
  99.                 this.txtInfo.AppendText(msg + "\r\n");
  100.             });
  102.         }
  103.     }
  104. }
复制代码
 
实例演示

 
经过上述步骤，运行程序，然后点击Work按钮，默认无故障时如下所示：
5.gif

当勾选故障，模拟出现故障时，如下所示：
6.gif

以上就是《推荐一款高性能状态机管理解决方案》，旨在抛砖引玉，一起学习，共同进步。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
啦汇
2025-8-15 21:02:46

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫