更新:
再次感谢你的例子，它们对我很有帮助，我并不是说
夺走他们的一切。
Aren't the currently given examples, as far as I understand them & state-machines, only half of what we usually understand by a state-machine?
In the sense that the examples do change state but that's only represented by changing the value of a variable (and allowing different value- changes in different states), while usually, a state machine should also change its behavior, and behavior not (only) in the sense of allowing different value changes for a variable depending on the state, but in the sense of allowing different methods to be executed for different states.
还是我对状态机及其常用用法有误解?
最初的问题:
我发现了关于c#中的状态机和迭代器块的讨论，以及用于创建状态机和c#的工具，所以我发现了很多抽象的东西，但作为一个新手，所有这些都有点令人困惑。
因此，如果有人能提供一个c#源代码-示例，实现一个简单的状态机，可能只有3,4个状态，那就太好了，只是为了了解它的要点。
我还没有尝试过在c#中实现FSM，但这些听起来(或看起来)与我过去在C或ASM等低级语言中处理FSM的方式非常复杂。
我相信我所知道的方法被称为“迭代循环”。在其中，你实际上有一个“while”循环，它周期性地根据事件(中断)退出，然后再次返回到主循环。
在中断处理程序中，您将传递一个CurrentState并返回一个NextState，然后在主循环中覆盖CurrentState变量。你可以无限地这样做，直到程序关闭(或微控制器复位)。
在我看来，与FSM的实现方式相比，我看到的其他答案都显得非常复杂;它的美丽在于它的简单性，FSM可以非常复杂，有很多很多的状态和过渡，但它们允许复杂的过程很容易被分解和消化。
我知道我的回答不应该包含另一个问题，但我不得不问:为什么这些其他提出的解决方案看起来如此复杂?
它们似乎类似于用一个巨大的大锤敲一个小钉子。
其他替代在此回购https://github.com/lingkodsoft/StateBliss
使用流畅的语法，支持触发器。
public class BasicTests
{
[Fact]
public void Tests()
{
// Arrange
StateMachineManager.Register(new [] { typeof(BasicTests).Assembly }); //Register at bootstrap of your application, i.e. Startup
var currentState = AuthenticationState.Unauthenticated;
var nextState = AuthenticationState.Authenticated;
var data = new Dictionary<string, object>();
// Act
var changeInfo = StateMachineManager.Trigger(currentState, nextState, data);
// Assert
Assert.True(changeInfo.StateChangedSucceeded);
Assert.Equal("ChangingHandler1", changeInfo.Data["key1"]);
Assert.Equal("ChangingHandler2", changeInfo.Data["key2"]);
}
//this class gets regitered automatically by calling StateMachineManager.Register
public class AuthenticationStateDefinition : StateDefinition<AuthenticationState>
{
public override void Define(IStateFromBuilder<AuthenticationState> builder)
{
builder.From(AuthenticationState.Unauthenticated).To(AuthenticationState.Authenticated)
.Changing(this, a => a.ChangingHandler1)
.Changed(this, a => a.ChangedHandler1);
builder.OnEntering(AuthenticationState.Authenticated, this, a => a.OnEnteringHandler1);
builder.OnEntered(AuthenticationState.Authenticated, this, a => a.OnEnteredHandler1);
builder.OnExiting(AuthenticationState.Unauthenticated, this, a => a.OnExitingHandler1);
builder.OnExited(AuthenticationState.Authenticated, this, a => a.OnExitedHandler1);
builder.OnEditing(AuthenticationState.Authenticated, this, a => a.OnEditingHandler1);
builder.OnEdited(AuthenticationState.Authenticated, this, a => a.OnEditedHandler1);
builder.ThrowExceptionWhenDiscontinued = true;
}
private void ChangingHandler1(StateChangeGuardInfo<AuthenticationState> changeinfo)
{
var data = changeinfo.DataAs<Dictionary<string, object>>();
data["key1"] = "ChangingHandler1";
}
private void OnEnteringHandler1(StateChangeGuardInfo<AuthenticationState> changeinfo)
{
// changeinfo.Continue = false; //this will prevent changing the state
}
private void OnEditedHandler1(StateChangeInfo<AuthenticationState> changeinfo)
{
}
private void OnExitedHandler1(StateChangeInfo<AuthenticationState> changeinfo)
{
}
private void OnEnteredHandler1(StateChangeInfo<AuthenticationState> changeinfo)
{
}
private void OnEditingHandler1(StateChangeGuardInfo<AuthenticationState> changeinfo)
{
}
private void OnExitingHandler1(StateChangeGuardInfo<AuthenticationState> changeinfo)
{
}
private void ChangedHandler1(StateChangeInfo<AuthenticationState> changeinfo)
{
}
}
public class AnotherAuthenticationStateDefinition : StateDefinition<AuthenticationState>
{
public override void Define(IStateFromBuilder<AuthenticationState> builder)
{
builder.From(AuthenticationState.Unauthenticated).To(AuthenticationState.Authenticated)
.Changing(this, a => a.ChangingHandler2);
}
private void ChangingHandler2(StateChangeGuardInfo<AuthenticationState> changeinfo)
{
var data = changeinfo.DataAs<Dictionary<string, object>>();
data["key2"] = "ChangingHandler2";
}
}
}
public enum AuthenticationState
{
Unauthenticated,
Authenticated
}
}
finitestatemmachine是一个简单的状态机，用c# Link编写
使用我的库finitestatemmachine的优点:
定义一个“context”类，向外界呈现一个单独的接口。
定义一个State抽象基类。
将状态机的不同“状态”表示为state基类的派生类。
在适当的State派生类中定义特定于状态的行为。
在“context”类中维护一个指向当前“state”的指针。
要更改状态机的状态，请更改当前的“state”指针。
下载DLL下载
LINQPad上的示例:
void Main()
{
var machine = new SFM.Machine(new StatePaused());
var output = machine.Command("Input_Start", Command.Start);
Console.WriteLine(Command.Start.ToString() + "-> State: " + machine.Current);
Console.WriteLine(output);
output = machine.Command("Input_Pause", Command.Pause);
Console.WriteLine(Command.Pause.ToString() + "-> State: " + machine.Current);
Console.WriteLine(output);
Console.WriteLine("-------------------------------------------------");
}
public enum Command
{
Start,
Pause,
}
public class StateActive : SFM.State
{
public override void Handle(SFM.IContext context)
{
//Gestione parametri
var input = (String)context.Input;
context.Output = input;
//Gestione Navigazione
if ((Command)context.Command == Command.Pause) context.Next = new StatePaused();
if ((Command)context.Command == Command.Start) context.Next = this;
}
}
public class StatePaused : SFM.State
{
public override void Handle(SFM.IContext context)
{
//Gestione parametri
var input = (String)context.Input;
context.Output = input;
//Gestione Navigazione
if ((Command)context.Command == Command.Start) context.Next = new StateActive();
if ((Command)context.Command == Command.Pause) context.Next = this;
}
}
记住状态机是一种抽象是很有用的，创建状态机不需要特定的工具，但是工具是有用的。
例如，你可以用函数实现一个状态机:
void Hunt(IList<Gull> gulls)
{
if (gulls.Empty())
return;
var target = gulls.First();
TargetAcquired(target, gulls);
}
void TargetAcquired(Gull target, IList<Gull> gulls)
{
var balloon = new WaterBalloon(weightKg: 20);
this.Cannon.Fire(balloon);
if (balloon.Hit)
{
TargetHit(target, gulls);
}
else
TargetMissed(target, gulls);
}
void TargetHit(Gull target, IList<Gull> gulls)
{
Console.WriteLine("Suck on it {0}!", target.Name);
Hunt(gulls);
}
void TargetMissed(Gull target, IList<Gull> gulls)
{
Console.WriteLine("I'll get ya!");
TargetAcquired(target, gulls);
}
这台机器会捕捉海鸥，并试图用水球击中它们。如果它没有命中，它将尝试发射一个直到命中为止(可以有一些现实的期望;))，否则它将在控制台幸灾乐祸。它继续捕猎，直到没有海鸥可以骚扰为止。
每个函数对应于每个状态;没有显示开始和结束(或接受)状态。其中的状态可能比函数所模拟的要多。例如，在发射气球后，机器实际上处于与之前不同的状态，但我认为这种区分是不切实际的。
常用的方法是使用类来表示状态，然后以不同的方式将它们连接起来。
