blocks|key|3116136|text|你可以把你看到的每个UI看作一个大的状态机。来自UI的每个事件(例如，按钮单击、菜单选择等)驱动转换到另一个状态，这可能意味着一个新的页面。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116137|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You can think of every UI you see as one big state machine. Every event from the UI (e.g. button click, menu selection, etc.) drives a transition to another state, which could mean a new page.

blocks|key|4583669|text|您的操作系统内核调度器/分派器是一个状态机。线程具有运行、就绪、睡眠、eventWaiting、挂起、终止等状态。这些事件是来自IO设备驱动程序的硬件中断和来自正在运行的线程的软件中断。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4583670|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Your OS kernel scheduler/dispatcher is a state machine. The threads have states - running, ready, sleeping, eventWaiting, suspended, terminated. The events are the hardware interrupts from IO device drivers and software interrupts from running threads.

blocks|key|3116244|text|显示典型导航路径的网站设计(类似于@duffymo的答案)。这里有一个不完整的例子(灵感来自于“应用UML和模式”(Craig+Larman))：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116245|​|3116246|📷|atomic|offset|length|3116247|3116248|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/a98604136a646070dc308aad73fcc790.png|imageAlt^0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@$G|V|H|W|1|X]]|A|$]]|$1|I|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q|R|-4]]]]

Web site design showing typical navigation paths (similar to @duffymo's answer). Here's an incomplete example (inspired from "Applying UML and Patterns" (Craig Larman)):

<img src="https://i.stack.imgur.com/0HADO.png" alt="enter image description here">

blocks|key|995572|text|另一种情况是排序。新订单(处于新状态)可以取消或修改，但不能退款。但是，一旦它处于已完成状态，它就不能被取消，但它可能会被退款。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|995573|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Another scenario is ordering. A new order (in new state) can be cancelled or modified, but not refunded. But, once you have it in completed state, it can not be cancelled, but it might be refunded.

blocks|key|995591|text|以某种方式，随机数生成器也可以被视为状态机。你有一组输入，比如左移，加常量，乘以常量等等。状态是一个实际的当前随机值。由于此类随机数的计数是有限的，因此可以将其视为某种有限状态机。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|995592|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Random number generator can somehow be considered also as a state machine. You have a set of inputs like shift left, add constant, multiply by a constant etc. A state is an actual current random value. Since the count of such random numbers is finite, it can be considered as a some kind of finite state machine.

blocks|key|800295|text|有关状态机(以Umple表示)的一些示例，请参阅：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|800296|渠道锁软件：http://cruise.eecs.uottawa.ca/umpleonline/?example=CanalLockStateMachine&diagramtype=state|offset|length|800297|电信呼叫处理：http://cruise.eecs.uottawa.ca/umpleonline/?example=Phone&diagramtype=state|800298|车库门软件：http://cruise.eecs.uottawa.ca/umpleonline/?example=GarageDoor&diagramtype=state|800299|在航空公司预订系统预订：http://cruise.eecs.uottawa.ca/umpleonline/?example=Booking&diagramtype=state|800300|entityMap|0|LINK|mutability|MUTABLE|url|http://cruise.eecs.uottawa.ca/umpleonline/?example=CanalLockStateMachine&diagramtype=state|1|http://cruise.eecs.uottawa.ca/umpleonline/?example=Phone&diagramtype=state|2|http://cruise.eecs.uottawa.ca/umpleonline/?example=GarageDoor&diagramtype=state|3|http://cruise.eecs.uottawa.ca/umpleonline/?example=Booking&diagramtype=state^0|0|6|2I|0|0|7|22|1|0|6|27|2|0|C|24|3|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]]|A|$]]|$1|F|3|G|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@$D|19|E|1A|1|1B]]|A|$]]|$1|J|3|K|5|6|7|1C|8|@]|9|@$D|1D|E|1E|1|1F]]|A|$]]|$1|L|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]|T|$5|O|P|Q|A|$R|U]]|V|$5|O|P|Q|A|$R|W]]|X|$5|O|P|Q|A|$R|Y]]]]

For some examples of state machines (represented in Umple) see:

Canal lock software:
<a href="http://cruise.eecs.uottawa.ca/umpleonline/?example=CanalLockStateMachine&amp;diagramtype=state" rel="nofollow">http://cruise.eecs.uottawa.ca/umpleonline/?example=CanalLockStateMachine&amp;diagramtype=state</a>

Telecom call processing:
<a href="http://cruise.eecs.uottawa.ca/umpleonline/?example=Phone&amp;diagramtype=state" rel="nofollow">http://cruise.eecs.uottawa.ca/umpleonline/?example=Phone&amp;diagramtype=state</a>

Garage door software:
<a href="http://cruise.eecs.uottawa.ca/umpleonline/?example=GarageDoor&amp;diagramtype=state" rel="nofollow">http://cruise.eecs.uottawa.ca/umpleonline/?example=GarageDoor&amp;diagramtype=state</a>

Booking in an airline reservation system:
<a href="http://cruise.eecs.uottawa.ca/umpleonline/?example=Booking&amp;diagramtype=state" rel="nofollow">http://cruise.eecs.uottawa.ca/umpleonline/?example=Booking&amp;diagramtype=state</a>

blocks|key|995666|text|opengl库是一个状态机。它保持一种状态，该状态根据对库函数的调用而变化。你可以在这里看到：http://www.cs.tufts.edu/research/graphics/resources/OpenGL/OpenGL.htm|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|995667|状态机可以使用的另一个范围是视频游戏。想象一下，一个相对聪明的敌人。这个敌人将有几种状态:攻击，躲藏，死亡，奔跑等等。这可以由状态和事件控制。当我写一个视频游戏作为我的学位项目时，我使用了两个状态机:一个用于游戏流程(演示屏幕、游戏、选项等)，另一个用于游戏本身(提问、掷骰子、移动玩家等)。|995668|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.tufts.edu/research/graphics/resources/OpenGL/OpenGL.htm^0|1B|1X|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

The opengl library is a state machine. It keeps a status that changes depending on the calls to the library functions. You can see it here: <a href="http://www.cs.tufts.edu/research/graphics/resources/OpenGL/OpenGL.htm" rel="nofollow">http://www.cs.tufts.edu/research/graphics/resources/OpenGL/OpenGL.htm</a>

Another scope in which the state machines could be used is in video games. Imagine one enemy that is relatively intelligent. This enemy will have several statuses: attacking, hiding, dying, running, etc. This could be controlled by states and events. When I wrote a video game as my degree project I used two state machines: one for the game flow (presentation screen, game, options, etc) and the other for the game itself (asking question, throwing the dice, moving player, etc)

blocks|key|3116346|text|这是一个基本FSM的玩具控制台应用程序示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3116347|using+System;
using+System.Collections.Generic;
using+System.Linq;
using+System.Text;

//++DESC:+QAD-FSM+(Quick+And+Dirty+Finite+State+Machine)
//++
//++Notes:+In+its+simplest+form+a+state+machine+is
//+++++++•+A+set+of+states
//+++++++•+A+set+of+events
//+++++++•+A+set+of+transitions+that+define+
//+++++++++++the+next+state+given+the+current+state+and+event.
//+++++++•+A+method+of+tracking+current+state
//+
//++Example:
//+
//+++++++I+want+to+create+a+different+kind+of+door+lock+that
//+++++++++++has+the+following+states:
//++++++++++
//+++++++++++++++1.+LBS+-+Locked_Both_Sides
//+++++++++++++++2.+UBS+-+Unlocked_Both_Sides
//+++++++++++++++3.+LFO+-+Locked_From_Outside
//+
//+++++++++++and+has+the+following+events:
//++++++++++
//+++++++++++++++1.+OKT+-+Outside+Key+Turn
//+++++++++++++++2.+IKT+-+Inside+Key+Turn
//++++++++++++++
//+++++++Transistions+will+be+as+follows:
//++++++
//+++++++CurrState++Event+++NextState+++Desc
//+++++++========================================================
//+++++++LBS++++++++++++OKT+++++UBS+++++++++When+both+sides+locked,+outside+key+turn+unlocks+both+sides
//+++++++LBS++++++++++++IKT+++++LFO+++++++++When+both+sides+locked,+inside+key+turn+unlocks+inside
//+++++++UBS++++++++++++OKT+++++LFO+++++++++When+both+sides+unlocked,+outside+key+turn+locks+outside
//+++++++UBS++++++++++++IKT+++++LBS+++++++++When+both+sides+unlocked,+inside+key+turn+locks+both+sides
//+++++++LFO++++++++++++OKT+++++UBS+++++++++When+only+outside+locked,+outside+key+turn+unlocks+outside
//+++++++LFO++++++++++++IKT+++++LBS+++++++++When+only+outside+locked,+inside+key+turn+locks+both+sides.

namespace+FSM
{
++++//+The+FSM+states
++++enum+State
++++{
++++++++LBS,
++++++++UBS,
++++++++LFO
++++}

++++//+The+FSM+events
++++enum+Event
++++{
++++++++IKT,
++++++++OKT
++++}

++++class+Transition
++++{
++++++++public+State+currState+{+get;+set;+}
++++++++public+Event+evnt+{+get;+set;+}
++++++++public+State+nextState+{+get;+set;+}
++++}

++++class+Program
++++{
++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++var+fsm+=+new+FSM();

++++++++++++System.Console.WriteLine("Current+State:+"+%2B+fsm.StateDesc[fsm.CurrentState]);

++++++++++++string+input+=+"";
++++++++++++while+(input+!=+"x")
++++++++++++{
++++++++++++++++System.Console.Write("Enter+key+turn+[IKT,+OKT]+or+x+to+exit:+");
++++++++++++++++input+=+System.Console.ReadLine();
++++++++++++++++if+(input+==+"x")+break;
++++++++++++++++Event+evnt;
++++++++++++++++if+(!Enum.TryParse(input,+out+evnt))
++++++++++++++++{
++++++++++++++++++++System.Console.WriteLine("Invalid+input:+"+%2B+input+%2B+",+enter+one+of+[IKT,OKT,x]");
++++++++++++++++++++continue;
++++++++++++++++}
++++++++++++++++fsm.ChangeState(evnt);
++++++++++++++++System.Console.WriteLine("New+State:+"+%2B+fsm.StateDesc[fsm.CurrentState]);
++++++++++++}

++++++++++++System.Console.WriteLine("");
++++++++++++System.Console.WriteLine("History");
++++++++++++System.Console.WriteLine("===============================================");
++++++++++++System.Console.WriteLine("CurrState(Event)+=>+NextState");
++++++++++++System.Console.WriteLine("===============================================");
++++++++++++fsm.hist
++++++++++++++++.Select(h+=>+h.currState.ToString()+%2B+"("+%2B+h.evnt.ToString()+%2B+")+=>+"+%2B+h.nextState.ToString())
++++++++++++++++.ToList()
++++++++++++++++.ForEach(h+=>+System.Console.WriteLine(h));
++++++++}
++++}

++++class+FSM
++++{
++++++++public+Dictionary<State,+String>+StateDesc+=+new+Dictionary<State,+String>()
++++++++++++++++++++++++++++++++++++++++++++++++{+
++++++++++++++++++++++++++++++++++++++++++++++++++++{State.LBS,+"Both+Sides+Locked"},
++++++++++++++++++++++++++++++++++++++++++++++++++++{State.LFO,+"Locked+From+Outside"},
++++++++++++++++++++++++++++++++++++++++++++++++++++{State.UBS,+"Both+Sides+Unlocked"}
++++++++++++++++++++++++++++++++++++++++++++++++};

++++++++public+List<Transition>+hist+=+new+List<Transition>();

++++++++//+Create+FSM+transitions.
++++++++List<Transition>+trans+=+new+List<Transition>
++++++++++++{
++++++++++++++++new+Transition()+{+currState+=+State.LBS,+evnt+=+Event.OKT,+nextState+=+State.UBS+},+
++++++++++++++++new+Transition()+{+currState+=+State.LBS,+evnt+=+Event.IKT,+nextState+=+State.LFO+},+
++++++++++++++++new+Transition()+{+currState+=+State.UBS,+evnt+=+Event.OKT,+nextState+=+State.LFO+},+
++++++++++++++++new+Transition()+{+currState+=+State.UBS,+evnt+=+Event.IKT,+nextState+=+State.LBS+},+
++++++++++++++++new+Transition()+{+currState+=+State.LFO,+evnt+=+Event.OKT,+nextState+=+State.UBS+},+
++++++++++++++++new+Transition()+{+currState+=+State.LFO,+evnt+=+Event.IKT,+nextState+=+State.LBS+},+
++++++++++++};

++++++++public+State+CurrentState+{+get+{+var+lt+=+hist.FirstOrDefault();+return+lt+==+null+?+State.UBS+:+lt.nextState;+}+}

++++++++public+State?+ChangeState(Event+evnt)
++++++++{
++++++++++++var+t+=+trans.Find(r+=>+r.currState+==+CurrentState+&&+r.evnt+==+evnt);
++++++++++++if+(t+==+null)+return+null;+//+If+you+don't+create+transitions+that+cover+all+combinations+this+could+happen.
++++++++++++hist.Insert(0,+t);
++++++++++++return+t.nextState;
++++++++}
++++}
}|code-block|syntax|javascript|3116348|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a toy console app example of a basic FSM.

<pre><code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

// DESC: QAD-FSM (Quick And Dirty Finite State Machine)
// 
// Notes: In its simplest form a state machine is
// • A set of states
// • A set of events
// • A set of transitions that define 
// the next state given the current state and event.
// • A method of tracking current state
// 
// Example:
// 
// I want to create a different kind of door lock that
// has the following states:
// 
// 1. LBS - Locked_Both_Sides
// 2. UBS - Unlocked_Both_Sides
// 3. LFO - Locked_From_Outside
// 
// and has the following events:
// 
// 1. OKT - Outside Key Turn
// 2. IKT - Inside Key Turn
// 
// Transistions will be as follows:
// 
// CurrState Event NextState Desc
// ========================================================
// LBS OKT UBS When both sides locked, outside key turn unlocks both sides
// LBS IKT LFO When both sides locked, inside key turn unlocks inside
// UBS OKT LFO When both sides unlocked, outside key turn locks outside
// UBS IKT LBS When both sides unlocked, inside key turn locks both sides
// LFO OKT UBS When only outside locked, outside key turn unlocks outside
// LFO IKT LBS When only outside locked, inside key turn locks both sides.

namespace FSM
{
 // The FSM states
 enum State
 {
 LBS,
 UBS,
 LFO
 }

 // The FSM events
 enum Event
 {
 IKT,
 OKT
 }

 class Transition
 {
 public State currState { get; set; }
 public Event evnt { get; set; }
 public State nextState { get; set; }
 }

 class Program
 {
 static void Main(string[] args)
 {
 var fsm = new FSM();

 System.Console.WriteLine("Current State: " + fsm.StateDesc[fsm.CurrentState]);

 string input = "";
 while (input != "x")
 {
 System.Console.Write("Enter key turn [IKT, OKT] or x to exit: ");
 input = System.Console.ReadLine();
 if (input == "x") break;
 Event evnt;
 if (!Enum.TryParse(input, out evnt))
 {
 System.Console.WriteLine("Invalid input: " + input + ", enter one of [IKT,OKT,x]");
 continue;
 }
 fsm.ChangeState(evnt);
 System.Console.WriteLine("New State: " + fsm.StateDesc[fsm.CurrentState]);
 }

 System.Console.WriteLine("");
 System.Console.WriteLine("History");
 System.Console.WriteLine("===============================================");
 System.Console.WriteLine("CurrState(Event) =&gt; NextState");
 System.Console.WriteLine("===============================================");
 fsm.hist
 .Select(h =&gt; h.currState.ToString() + "(" + h.evnt.ToString() + ") =&gt; " + h.nextState.ToString())
 .ToList()
 .ForEach(h =&gt; System.Console.WriteLine(h));
 }
 }

 class FSM
 {
 public Dictionary&lt;State, String&gt; StateDesc = new Dictionary&lt;State, String&gt;()
 { 
 {State.LBS, "Both Sides Locked"},
 {State.LFO, "Locked From Outside"},
 {State.UBS, "Both Sides Unlocked"}
 };

 public List&lt;Transition&gt; hist = new List&lt;Transition&gt;();

 // Create FSM transitions.
 List&lt;Transition&gt; trans = new List&lt;Transition&gt;
 {
 new Transition() { currState = State.LBS, evnt = Event.OKT, nextState = State.UBS }, 
 new Transition() { currState = State.LBS, evnt = Event.IKT, nextState = State.LFO }, 
 new Transition() { currState = State.UBS, evnt = Event.OKT, nextState = State.LFO }, 
 new Transition() { currState = State.UBS, evnt = Event.IKT, nextState = State.LBS }, 
 new Transition() { currState = State.LFO, evnt = Event.OKT, nextState = State.UBS }, 
 new Transition() { currState = State.LFO, evnt = Event.IKT, nextState = State.LBS }, 
 };

 public State CurrentState { get { var lt = hist.FirstOrDefault(); return lt == null ? State.UBS : lt.nextState; } }

 public State? ChangeState(Event evnt)
 {
 var t = trans.Find(r =&gt; r.currState == CurrentState &amp;&amp; r.evnt == evnt);
 if (t == null) return null; // If you don't create transitions that cover all combinations this could happen.
 hist.Insert(0, t);
 return t.nextState;
 }
 }
}
</code></pre>

blocks|key|800417|text|您可以在.net中看到我的通用状态机，它使用面向方面编程作为实现示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|800418|它可以在需要一些工作流逻辑的软件中使用，比如审批工作流。|800419|https://github.com/rcarubbi/carubbi.statemachine|offset|length|800420|只需像这样创建实体：|800421|++++[InitialState("State1")]
++++public+class+Entity+:+IStatedEntity
++++{

++++++++[Transition(From+=+"State1",+To+=+"State2")]
++++++++[Transition(From+=+"State3",+To+=+"State1")]
++++++++public+void+Method1()
++++++++{
++++++++++++Trace.WriteLine("Method1");
++++++++}

++++++++[Transition(From+=+"State2",+To+=+"State1")]
++++++++public+string+Method2()
++++++++{
++++++++++++Trace.WriteLine("Method2");
++++++++++++return+string.Empty;
++++++++}

++++++++[Transition(From+=+"State2",+To+=+"State3")]
++++++++[Transition(From+=+"State3",+To+=+"State4")]
++++++++public+int+Method3(int+p1,+int+p2)
++++++++{
++++++++++++Trace.WriteLine("Method3");
++++++++++++return+p1+%2B+p2;
++++++++}


++++++++public+StateMachine+StateMachine+{+get;+set;+}
+++}|code-block|syntax|javascript|800422|并这样使用它：|800423|++++++[TestMethod]
++++++++public+void+TestMethod1()
++++++++{
++++++++++++StateMachine.Configure();
++++++++++++var+ent+=+new+Entity
++++++++++++{
++++++++++++++++StateMachine+=
++++++++++++++++{
++++++++++++++++++++IgnoreInvalidOperations+=+true
++++++++++++++++}
++++++++++++};

++++++++++++ent.StateMachine.TransitionStarted+%2B=+StateMachine_TransitionStarted;
++++++++++++ent.StateMachine.TransitionEnded+%2B=+StateMachine_TransitionEnded;

++++++++++++Trace.WriteLine(ent.StateMachine.CurrentState);
++++++++++++ent.Method1();
++++++++++++Trace.WriteLine(ent.StateMachine.CurrentState);
++++++++++++ent.Method2();
++++++++++++Trace.WriteLine(ent.StateMachine.CurrentState);
++++++++++++ent.Method1();
++++++++++++Trace.WriteLine(ent.StateMachine.CurrentState);
++++++++++++var+result+=+ent.Method3(2,+4);
++++++++++++Trace.WriteLine(ent.StateMachine.CurrentState);
++++++++++++var+result2+=+ent.Method3(4,+4);
++++++++++++Trace.WriteLine(ent.StateMachine.CurrentState);
++++++++++++var+result3+=+ent.Method3(4,+4);
++++++++++++Trace.WriteLine(ent.StateMachine.CurrentState);
++++++++}

++++++++private+void+StateMachine_TransitionEnded(object+sender,+TransitionEventArgs+e)
++++++++{

++++++++}


++++++++private+void+StateMachine_TransitionStarted(object+sender,+TransitionStartedEventArgs+e)
++++++++{

++++++++}
+++}|800424|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1C|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@$F|12|G|13|1|14]]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|16|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|18|8|@]|9|@]|A|$M|N]]|$1|S|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|E]]]]

You can see my Generic State Machine in .net using Aspect-Oriented-Programming as an example of implementation.

It can be used in a software that need some workflow logic like an approval workflow.

<a href="https://github.com/rcarubbi/carubbi.statemachine" rel="nofollow noreferrer">https://github.com/rcarubbi/carubbi.statemachine</a>

Just create your entity like this:

<pre><code> [InitialState("State1")]
 public class Entity : IStatedEntity
 {

 [Transition(From = "State1", To = "State2")]
 [Transition(From = "State3", To = "State1")]
 public void Method1()
 {
 Trace.WriteLine("Method1");
 }

 [Transition(From = "State2", To = "State1")]
 public string Method2()
 {
 Trace.WriteLine("Method2");
 return string.Empty;
 }

 [Transition(From = "State2", To = "State3")]
 [Transition(From = "State3", To = "State4")]
 public int Method3(int p1, int p2)
 {
 Trace.WriteLine("Method3");
 return p1 + p2;
 }


 public StateMachine StateMachine { get; set; }
 }
</code></pre>

and use it this way:

<pre><code> [TestMethod]
 public void TestMethod1()
 {
 StateMachine.Configure();
 var ent = new Entity
 {
 StateMachine =
 {
 IgnoreInvalidOperations = true
 }
 };

 ent.StateMachine.TransitionStarted += StateMachine_TransitionStarted;
 ent.StateMachine.TransitionEnded += StateMachine_TransitionEnded;

 Trace.WriteLine(ent.StateMachine.CurrentState);
 ent.Method1();
 Trace.WriteLine(ent.StateMachine.CurrentState);
 ent.Method2();
 Trace.WriteLine(ent.StateMachine.CurrentState);
 ent.Method1();
 Trace.WriteLine(ent.StateMachine.CurrentState);
 var result = ent.Method3(2, 4);
 Trace.WriteLine(ent.StateMachine.CurrentState);
 var result2 = ent.Method3(4, 4);
 Trace.WriteLine(ent.StateMachine.CurrentState);
 var result3 = ent.Method3(4, 4);
 Trace.WriteLine(ent.StateMachine.CurrentState);
 }

 private void StateMachine_TransitionEnded(object sender, TransitionEventArgs e)
 {

 }


 private void StateMachine_TransitionStarted(object sender, TransitionStartedEventArgs e)
 {

 }
 }
</code></pre>

Could somebody say a good example of usage of State machine in software (except compilators and parsers)? There are examples of a great practical importance and usage of state machine should simplify software:-) 

I want to write .NET application.

Thanks.

State Machine example

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

有人能说出状态机在软件(编译器和解析器除外)中使用的一个很好的例子吗？有一些非常实用的例子，状态机的使用可以简化软件：-)我想写.NET应用程序。谢谢。

问状态机示例
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问状态机示例EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问状态机示例
EN