# StatusMachineSimulator

**Repository Path**: XUSHIHAOO/status-machine-simulator

## Basic Information

- **Project Name**: StatusMachineSimulator
- **Description**: No description available
- **Primary Language**: C#
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-04-20
- **Last Updated**: 2025-04-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# C# 状态机模拟器文档

## 概述

本状态机模拟器通过 C# 程序与 Lua 脚本文件的结合实现，用于流程控制与软件交互测试。Lua 脚本负责定义状态、事件、转换规则以及相关动作，C# 程序负责解析脚本并模拟状态机的运行。该模拟器支持灵活的状态机配置，便于验证复杂的业务逻辑和交互流程。

---

## 功能说明

1. **Lua 脚本定义**  
   - 状态（States）：定义状态机的各个状态及其属性。
   - 事件（Events）：定义触发状态转换的事件及其参数。
   - 转换规则（Transitions）：定义状态与事件之间的转换逻辑。
   - 动作（Actions）：定义状态转换时执行的操作。

2. **C# 状态机引擎**  
   - 解析 Lua 脚本，构建状态机模型。
   - 提供手动触发与自动执行模式。
   - 记录状态转换日志，支持断言与验证。

3. **流程控制与测试**  
   - 模拟状态机运行，验证流程控制逻辑。
   - 支持复杂的事件序列与条件判断。
   - 提供调试信息，便于问题定位。

---

## Lua 脚本定义示例

### 1. 状态定义

```lua
-- states.lua
states = {
    { id = "Idle", description = "初始状态" },
    { id = "Processing", description = "处理中状态" },
    { id = "Completed", description = "完成状态" }
}
```

### 2. 事件定义
```lua
-- events.lua
events = {
    { name = "Start", parameters = { "param1" } },
    { name = "Finish", parameters = {} }
}
```

### 3. 转换规则定义
```lua
-- transitions.lua
transitions = {
    {
        sourceState = "Idle",
        event = "Start",
        targetState = "Processing",
        condition = "param1 > 0",
        actions = { "Log('开始处理')", "UpdateUI()" }
    },
    {
        sourceState = "Processing",
        event = "Finish",
        targetState = "Completed",
        actions = { "Log('处理完成')" }
    }
}
```

### 4. 动作定义（可选，直接在转换规则中引用）
动作可以以字符串形式直接写在转换规则中（如上例），也可以单独定义函数，通过反射或约定调用。

C# 实现
核心类设计
State：表示状态，包含 ID、描述等属性。
Event：表示事件，包含名称、参数等属性。
Transition：表示转换规则，包含源状态、事件、目标状态、条件及动作。
StateMachine：状态机引擎，负责解析 Lua 脚本并管理状态转换。
示例代码
csharp
using System;
using System.Collections.Generic;
using NLua; // 使用 NLua 库解析 Lua 脚本
 
public class State
{
    public string Id { get; set; }
    public string Description { get; set; }
}
 
public class Event
{
    public string Name { get; set; }
    public Dictionary<string, object> Parameters { get; set; }
}
 
public class Transition
{
    public State SourceState { get; set; }
    public Event Event { get; set; }
    public State TargetState { get; set; }
    public string Condition { get; set; }
    public List<string> Actions { get; set; }
}
 
public class StateMachine
{
    private State currentState;
    private List<State> states;
    private List<Event> events;
    private List<Transition> transitions;
 
    public StateMachine(string statesScript, string eventsScript, string transitionsScript)
    {
        states = LoadStates(statesScript);
        events = LoadEvents(eventsScript);
        transitions = LoadTransitions(transitionsScript);
        currentState = states.Find(s => s.Id == "Idle"); // 假设初始状态为 "Idle"
    }
 
    private List<State> LoadStates(string script)
    {
        // 使用 NLua 解析脚本并返回状态列表
        // 示例代码省略具体解析逻辑
        return new List<State>(); // 返回实际解析的状态列表
    }
 
    private List<Event> LoadEvents(string script)
    {
        // 类似 LoadStates，解析事件脚本
        return new List<Event>();
    }
 
    private List<Transition> LoadTransitions(string script)
    {
        // 类似 LoadStates，解析转换规则脚本
        return new List<Transition>();
    }
 
    public void TriggerEvent(string eventName, Dictionary<string, object> parameters)
    {
        var evt = events.Find(e => e.Name == eventName);
        if (evt == null) return;
 
        var applicableTransitions = transitions.FindAll(t =>
            t.SourceState == currentState && t.Event == evt &&
            EvaluateCondition(t.Condition, parameters));
 
        if (applicableTransitions.Count > 0)
        {
            var transition = applicableTransitions[0]; // 简单选择第一个匹配的转换
            ExecuteActions(transition.Actions, parameters);
            currentState = transition.TargetState;
        }
    }
 
    private bool EvaluateCondition(string condition, Dictionary<string, object> parameters)
    {
        // 使用 C# 表达式解析或脚本引擎评估条件
        // 示例代码省略具体实现
        return true; // 返回实际评估结果
    }
 
    private void ExecuteActions(List<string> actions, Dictionary<string, object> parameters)
    {
        foreach (var action in actions)
        {
            // 简单模拟动作执行，可扩展为反射调用或脚本执行
            Console.WriteLine($"执行动作: {action}");
        }
    }
}
 
class Program
{
    static void Main(string[] args)
    {
        var sm = new StateMachine("states.lua", "events.lua", "transitions.lua");
        sm.TriggerEvent("Start", new Dictionary<string, object> { { "param1", 10 } });
        sm.TriggerEvent("Finish", new Dictionary<string, object>());
    }
}
使用说明
准备 Lua 脚本：按照示例定义状态、事件、转换规则。
初始化状态机：在 C# 程序中创建 StateMachine 实例，传入 Lua 脚本路径。
触发事件：调用 TriggerEvent 方法，模拟状态机运行。
查看结果：检查控制台输出或日志，验证状态转换与动作执行。
注意事项
Lua 脚本解析：确保 Lua 脚本语法正确，避免解析错误。
条件评估：条件表达式需与 C# 环境兼容，或使用脚本引擎评估。
动作执行：动作执行逻辑需根据实际需求实现，避免阻塞或异常。
状态机设计：确保状态机设计合理，避免状态循环或死锁。
结论
本 C# 状态机模拟器通过 Lua 脚本与 C# 程序的结合，实现了灵活的状态机定义与模拟。它适用于复杂的流程控制与软件交互测试，帮助开发者验证业务逻辑的正确性。