一個狀態機的實現

interface IState
    {
        string Name { get; set; }

        //後件處理
        IList<IState> Nexts { get; set; }
        Func<IState /*this*/, IState /*next*/> Selector { get; set; }
        
    }

    class State : IState
    {
        public string Name { get; set; } = "State";

        IList<IState> IState.Nexts { get; set; } = new List<IState>();
        public Func<IState, IState> Selector { get; set; }

    }

狀態比較簡單，一個Name標識，一個後件狀態列表，而後一個狀態選擇器。

好比狀態a，能夠轉移到狀態b,c,d，那麼選擇器就是其中一個。至於怎麼選，就讓用戶來定義實際的選擇器了。

delegate bool HandleType<T>(IState current, IState previous,ref T value);
    interface IContext<T> : IEnumerator<T>, IEnumerable<T>
    {
        //data
        T Value { get; set; }
        //前件處理
        
        IDictionary<Tuple<IState/*this*/, IState/*previous*/>, HandleType<T>> Handles { get; set; }

        IState CurrentState { get; set; }
        bool transition(IState next);
    }

和狀態類State關注後件狀態不一樣，上下文類Context關注前件狀態。當跳轉到一個新的狀態，這個過程當中就要根據當前狀態來實施不一樣的策略。好比想進入狀態c，根據當前狀態是a, b,d 有不一樣的處理程序。這種轉移處理程序，是一一對應的，因此用了 Tuple<進入的狀態，當前狀態> 來描述一個跳轉鏈。而後用Dictionary 捆綁相關的處理程序。

上下文會攜帶 T Value 數據，要怎麼處理這種數據？我是經過ref 參數來傳遞給處理程序。由於我不想IState 關心上下文的構造，它只須要關注實際的數據 T value;

上下文保存數據和當前狀態，而後經過transiton 讓用戶控制狀態的轉移。這裏面有一個重複，由於IState有選擇器來控制狀態轉移了。爲何要這麼處理？我是爲了構造一個跳轉序列。引入IEnumerator和IEnumerable接口，然狀態能夠在選擇器的做用下自動跳轉，而後用foreach 讀取結果序列（只是不知道有什麼用）。

class Context<T> : IContext<T>
    {
        T data;
        T IContext<T>.Value { get=>data ; set=>data = value; }
        IDictionary<Tuple<IState, IState>, HandleType<T>> IContext<T>.Handles { get; set; } 
            = new Dictionary<Tuple<IState, IState>, HandleType<T>>();

        public IState CurrentState { get; set;}

        T IEnumerator<T>.Current =>  (this as IContext<T>).Value ;
        object IEnumerator.Current => (this as IContext<T>).Value;

        bool IContext<T>.transition(IState next)
        {
            IContext<T> context= this as IContext<T>;
            if (context.CurrentState == null || context.CurrentState.Nexts.Contains(next))
            {
                //前件處理
                var key = Tuple.Create(next, context.CurrentState);
                if (context.Handles.ContainsKey(key) && context.Handles[key] !=null)
                    if (!context.Handles[key](next, context.CurrentState,ref this.data))
                        return false;

                context.CurrentState = next;
                return true;
            }
            return false;
        }

        bool IEnumerator.MoveNext()
        {
            //後件處理
            IContext<T> context = this as IContext<T>;
            IState current = context.CurrentState; 
            if (current == null)
                throw new Exception("必須設置初始狀態");
            if (context.CurrentState.Selector != null)
            {
                IState next= context.CurrentState.Selector(context.CurrentState);
                return context.transition(next);
            }

            return false;
        }

        void IEnumerator.Reset()
        {
            throw new NotImplementedException();
        }

        #region IDisposable Support
        private bool disposedValue = false; // 要檢測冗餘調用

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // TODO: 釋放託管狀態(託管對象)。
                }

                // TODO: 釋放未託管的資源(未託管的對象)並在如下內容中替代終結器。
                // TODO: 將大型字段設置爲 null。

                disposedValue = true;
            }
        }

        // TODO: 僅當以上 Dispose(bool disposing) 擁有用於釋放未託管資源的代碼時才替代終結器。
        // ~Context() {
        //   // 請勿更改此代碼。將清理代碼放入以上 Dispose(bool disposing) 中。
        //   Dispose(false);
        // }

        // 添加此代碼以正確實現可處置模式。
        void IDisposable.Dispose()
        {
            // 請勿更改此代碼。將清理代碼放入以上 Dispose(bool disposing) 中。
            Dispose(true);
            // TODO: 若是在以上內容中替代了終結器，則取消註釋如下行。
            // GC.SuppressFinalize(this);
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return this;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this;
        }
        #endregion
    }

重點關注transition函數和MoveNext函數。

bool IContext<T>.transition(IState next)
        {
            IContext<T> context= this as IContext<T>;
            if (context.CurrentState == null || context.CurrentState.Nexts.Contains(next))
            {
                //前件處理
                var key = Tuple.Create(next, context.CurrentState);
                if (context.Handles.ContainsKey(key) && context.Handles[key] !=null)
                    if (!context.Handles[key](next, context.CurrentState,ref this.data))
                        return false;

                context.CurrentState = next;
                return true;
            }
            return false;
        }

作的事也很簡單，就是調用前件處理程序，處理成功就轉移狀態，不然退出。

bool IEnumerator.MoveNext()
        {
            //後件處理
            IContext<T> context = this as IContext<T>;
            IState current = context.CurrentState; 
            if (current == null)
                throw new Exception("必須設置初始狀態");
            if (context.CurrentState.Selector != null)
            {
                IState next= context.CurrentState.Selector(context.CurrentState);
                return context.transition(next);
            }

            return false;
        }

MoveNext經過選擇器來選擇下一個狀態。

總的來講，我這個狀態機的實現只是一個框架，沒有什麼功能，可是我感受是比較容易編寫狀態轉移目錄樹的。

用戶首先要建立一組狀態，而後創建目錄樹結構。個人實現比較粗糙，由於用戶要分別構建目錄樹，前件處理器，還有後件選擇器這三個部分。編寫測試代碼的時候，我寫了9個狀態的網狀結構，結果有點眼花繚亂。要是能統一塊兒來估計會更好一些。

要關注的是第一個狀態，和最後的狀態的構造，不然沒法停機，嵌入死循環。

//測試代碼
//---------建立部分---------
string mess = "";

//3            
IState s3 = new State() { Name = "s3" };
            
//2           
IState s2 = new State() { Name = "s2" };
            
//1           
IState s1 = new State() { Name = "s1" };

//---------組合起來---------            
s1.Nexts = new List<IState> { s2, s3 };           
s2.Nexts = new List<IState> { s1, s3 };            
s3.Nexts = new List<IState> { }; //注意end寫法

//---------上下文---------             
//transition            
IContext<int> cont = new Context<int> { CurrentState=s1};//begin            
cont.Value = 0;

//---------狀態處理器---------   
HandleType<int> funcLaji = (IState current, IState previous, ref int v) => { mess += $"{current.Name}:垃圾{previous.Name}\n"; v++; return true; };
            
//1            
cont.Handles.Add(Tuple.Create(s1 , default(IState)), funcLaji);            
cont.Handles.Add(Tuple.Create(s1, s2), funcLaji);
            
//2            
cont.Handles.Add(Tuple.Create(s2, s1), funcLaji);
            
//3            
cont.Handles.Add(Tuple.Create(s3, s1), funcLaji);   
cont.Handles.Add(Tuple.Create(s3, s2), funcLaji);

//---------狀態選擇器---------              
var rval = new Random();            
Func<int,int> round = x => rval.Next(x);            
s1.Selector = st => round(2)==0? s2:s3;            
s2.Selector = st => round(2)==0? s1:s3;

構造完畢後，就可使用這個狀態機了。

//選擇器跳轉            
mess += "選擇器跳轉：\n------------------------\n";
 
foreach (var stor in cont)
                mess+=$"狀態轉變次數：{stor}\n";
            
//直接控制跳轉
mess += "\n直接控制狀態跳轉：\n------------------------\n";

cont.transition(s1);
cont.transition(s2);
cont.transition(s3);

分享到此，謝謝。