fix and did start SM

Author: RomanSoloweow

SimpleStateMachineLibrary/Data/Data.cs

@@ -27,6 +27,8 @@ public Data OnChange(Action<Data, object, object> actionOnChange)
         protected internal Data(StateMachine stateMachine, string nameData, object valueData = null) : base(stateMachine, nameData)
         {
             Value = valueData;
+
+            stateMachine.AddData(this, true);
         }
 
         public Data Delete()

SimpleStateMachineLibrary/StateMachines/StateMachine.cs

@@ -19,6 +19,15 @@ public partial class StateMachine
 
         public State StartState { get; protected set; }
 
+        private Action<State, State> _onChangeState;
+
+        public StateMachine OnChangeState(Action<State, State> actionOnChangeState)
+        {
+            _onChangeState += actionOnChangeState;
+
+            return this;
+        }
+
         public StateMachine()
         {
 
@@ -41,6 +50,7 @@ public StateMachine(string xDocumentPath)
 
         private Dictionary<string, object> _nextParameters { get; set; }
 
+        private State _beforeState { get; set; }
 
 
         private void CheckStartState()
@@ -61,7 +71,8 @@ private void CheckCurrentTransition()
 
         public State SetStartState(State state)
         {
-            return SetStartState(state);
+            CheckStartState();
+            return StartState = state;
         }
 
         public State SetStartState(string stateName)
@@ -87,25 +98,29 @@ public void Start(Dictionary<string, object> startParameters = null)
         {
             CurrentState = StartState;
             CurrentState.Entry(startParameters);
+            _onChangeState?.Invoke(null, CurrentState);
             CurrentState.Exit(startParameters);
-            //while (CurrentState != EndState)
-            //{               
-            //    _currentParameters = _nextParameters;
-            //    _nextParameters = null;
-
-            //    CurrentTransition = _nextTransition;
-            //    _nextTransition = null;
-
-            //    CheckCurrentTransition();
-            //    CurrentState = null;
-            //    CurrentTransition.Invoke(_currentParameters);
-            //    CurrentState = CurrentTransition.StateTo;
-            //    CurrentTransition = null;
-
-            //    CurrentState.Entry(_currentParameters);
-            //    CurrentState.Exit(_currentParameters);                
-            //}
-        
+
+
+            while (_nextTransition != null)
+            {
+                _currentParameters = _nextParameters;
+                _nextParameters = null;
+
+                CurrentTransition = _nextTransition;
+                _nextTransition = null;
+
+                _beforeState = CurrentState;
+                CurrentState = null;
+                CurrentTransition.Invoke(_currentParameters);
+                CurrentState = CurrentTransition.StateTo;
+                CurrentTransition = null;
+
+                CurrentState.Entry(_currentParameters);
+                _onChangeState?.Invoke(_beforeState, CurrentState);
+                CurrentState.Exit(_currentParameters);
+            }
+
         }
 
     }

SimpleStateMachineLibrary/StateMachines/StateMachineWorkWithData.cs

@@ -42,6 +42,15 @@ private Data _AddData(string nameData, object valueData, bool exeption)
             return new Data(this, nameData, valueData);
         }
 
+        internal Data AddData(Data data, bool exeption)
+        {
+            if (!Check.NotContains(_data, data, exeption))
+                return null;
+
+            _data.Add(data.Name, data);
+            return data;
+        }
+
         public Data AddData(string nameData, object valueData = default(object))
         {
             return _AddData(nameData, valueData, true);

SimpleStateMachineLibrary/StateMachines/StateMachineWorkWithStates.cs

@@ -35,9 +35,17 @@ private State _AddState(string nameState, bool exeption)
         {
             if (!Check.NotContains(_states, nameState, exeption))
                 return null;
-
             return new State(this, nameState);
         }
+        internal State AddState(State state, bool exeption)
+        {
+            if (!Check.NotContains(_states, state, exeption))
+                return null;
+
+            _states.Add(state.Name, state);
+
+            return state;
+        }
 
         public State AddState(string nameState)
         {

SimpleStateMachineLibrary/StateMachines/StateMachineWorkWithTransitions.cs

@@ -41,6 +41,16 @@ private Transition _AddTransition(string nameTrancition, State stateFrom, State
             return new Transition(this, nameTrancition, stateFrom, stateTo);
         }
 
+        internal Transition AddTransition(Transition trancition, bool exeption)
+        {
+            if (!Check.NotContains(_transitions, trancition, exeption))
+                return null;
+
+            _transitions.Add(trancition.Name, trancition);
+
+            return trancition;
+        }
+
         public Transition AddTransition(string nameTrancition, State stateFrom, State stateTo)
         {
             return _AddTransition(nameTrancition, stateFrom, stateTo, true);

SimpleStateMachineLibrary/StateMachines/StateMachineWorkWithXML.cs

@@ -22,6 +22,13 @@ public static XDocument ToXDocument(StateMachine stateMachine, string nameFile)
                 states.Add(state.Value.ToXElement());
             }
 
+            if (stateMachine?.StartState != null)
+            {
+                XElement startState = new XElement("StartState");
+                stateMachineXElement.Add(startState);
+                startState.Add(new XAttribute("Name", stateMachine.StartState.Name));
+            }
+
             XElement transitions = new XElement("Transitions");
             stateMachineXElement.Add(transitions);
 
@@ -30,6 +37,8 @@ public static XDocument ToXDocument(StateMachine stateMachine, string nameFile)
                 transitions.Add(transition.Value.ToXElement());
             }
 
+
+
             xDocument.Save(nameFile);
             return xDocument;
         }
@@ -42,8 +51,17 @@ public XDocument ToXDocument(string nameFile)
         public static StateMachine FromXDocument(StateMachine stateMachine, XDocument xDocument)
         {
             XElement stateMachineXElement = Check.Object(xDocument).Element("StateMachine");
-            stateMachineXElement?.Element("States")?.Elements()?.ToList().ForEach(x => stateMachine.AddState(x));
-            stateMachineXElement?.Element("Transitions")?.Elements()?.ToList().ForEach(x => stateMachine.AddTransition(x));
+            var States = stateMachineXElement.Element("States")?.Elements()?.ToList();
+            States.ForEach(x => stateMachine.AddState(x));
+            var startState = stateMachineXElement.Element("StartState");
+            string nameStartState = startState?.Attribute("Name").Value;
+
+            if (!string.IsNullOrEmpty(nameStartState))
+                stateMachine.SetStartState(nameStartState);
+
+            var Transitions = stateMachineXElement.Element("Transitions")?.Elements()?.ToList();
+            Transitions.ForEach(x => stateMachine.AddTransition(x));
+           
             return stateMachine;
         }
 

SimpleStateMachineLibrary/States/State.cs

@@ -12,7 +12,7 @@ public partial class State : NamedObject<State>
 
         protected internal State(StateMachine stateMachine, string nameState) : base(stateMachine, nameState)
         {
-
+            StateMachine.AddState(this, true);
         }
 
         public State Delete()

SimpleStateMachineLibrary/Transitions/Transition.cs

@@ -16,6 +16,7 @@ protected internal Transition(StateMachine stateMachine, string nameTransition,
         {         
             StateFrom = stateFrom;
             StateTo = stateTo;
+            stateMachine.AddTransition(this, true);
         }
 
         public Transition Delete()

Tests/StateMachineUnitTests.cs

@@ -0,0 +1,68 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SimpleStateMachineLibrary;
+using System.Collections.Generic;
+
+namespace Tests
+{
+    [TestClass]
+    public class StateMachineUnitTests
+    {
+        void Method1(State state, Dictionary<string, object> parameters)
+        {
+            //Assert.AreEqual(parameters["Data1"], "Test Data");
+
+            state.StateMachine.InvokeTransitionWithParameters("Transition1", new Dictionary<string, object>() { { "Test1", "Test1" } });
+        }
+        void Method2(State state, Dictionary<string, object> parameters)
+        {
+            state.StateMachine.InvokeTransitionWithParameters("Transition2", new Dictionary<string, object>() { { "Test2", "Test2" } });
+        }
+        void MethodOnChange(State stateFrom, State stateTo)
+        {
+
+        }
+
+        [TestMethod]
+        public void StateMachineFromCode()
+        {
+            StateMachine stateMachine = new StateMachine();
+
+            State state1 = stateMachine.AddState("State1");
+            State state2 = stateMachine.AddState("State2");
+            State state3 = stateMachine.AddState("State3");
+
+            stateMachine.OnChangeState(MethodOnChange);
+
+            Transition transition1 = state1.AddTransitionFromThis("Transition1", state2);
+            Transition transition2 = stateMachine.AddTransition("Transition2", state2, state3);
+
+            state1.SetAsStartState();
+            state1.OnExit(Method1);
+            state2.OnExit(Method2);
+
+            var parametersForStart = new Dictionary<string, object>() { { "Data1", "Test Data" } };
+
+            stateMachine.Start(parametersForStart);
+
+            Assert.AreEqual(stateMachine.CurrentState.Name, "State3");
+
+            stateMachine.ToXDocument("text.xml");
+        }
+
+        [TestMethod]
+        public void StateMachineFromXML()
+        {
+            StateMachine stateMachine = StateMachine.FromXDocument("text.xml");
+
+            stateMachine.State("State1").OnExit(Method1);
+            stateMachine.State("State2").OnExit(Method2);
+
+            stateMachine.OnChangeState(MethodOnChange);
+
+            stateMachine.Start();
+
+            Assert.AreEqual(stateMachine.CurrentState.Name, "State3");
+        }
+
+    }
+}