new format

Author: RomanSoloweow

SimpleStateMachineLibrary/Data/Data.cs

@@ -24,6 +24,7 @@ public Data OnChange(Action<Data, object, object> actionOnChange)
 
             return this;
         }
+
         protected internal Data(StateMachine stateMachine, string nameData, object valueData = null) : base(stateMachine, nameData)
         {
             Value = valueData;

SimpleStateMachineLibrary/SimpleStateMachineLibrary.csproj

@@ -4,4 +4,10 @@
     <TargetFramework>netstandard2.1</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="3.1.2" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="3.1.2" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="3.1.2" />
+  </ItemGroup>
+
 </Project>

SimpleStateMachineLibrary/StateMachines/StateMachine.cs

@@ -13,13 +13,13 @@ public partial class StateMachine
 
         private Dictionary<string, Data> _data  = new Dictionary<string, Data>();
 
-        public State CurrentState { get; internal set; }
+        public State CurrentState { get; private set; }
 
-        public Transition CurrentTransition{ get; internal set; }
+        public State PreviousState { get; private set; }
 
-        public State StartState { get; protected set; }
+        public Transition CurrentTransition{ get; private set; }
 
-        private Action<State, State> _onChangeState;
+        public State StartState { get; private set; }
 
         public StateMachine OnChangeState(Action<State, State> actionOnChangeState)
         {
@@ -43,41 +43,22 @@ public StateMachine(string xDocumentPath)
             FromXDocument(this, xDocumentPath);
         }
 
-
         private Transition _nextTransition { get; set; }
 
         private Dictionary<string, object> _currentParameters { get; set; }
 
         private Dictionary<string, object> _nextParameters { get; set; }
 
-        private State _beforeState { get; set; }
-
-
-        private void CheckStartState()
-        {
-            if (StartState != null) 
-            {
-                throw new ArgumentException(String.Format("Start state already set. It's {0} ", StartState.Name));
-            }
-        }
-
-        private void CheckCurrentTransition()
-        {
-            if (CurrentTransition == null)
-            {
-                throw new ArgumentException(String.Format("State with name \"{0}\" doesn't invoke transition", CurrentState.Name));
-            }
-        }
+        private Action<State, State> _onChangeState;
 
         public State SetStartState(State state)
         {
-            CheckStartState();
-            return StartState = state;
+            StartState = state;
+            return state;
         }
 
         public State SetStartState(string stateName)
         {
-            CheckStartState();
             StartState = State(stateName);
             return StartState;
         }
@@ -94,31 +75,49 @@ public void InvokeTransitionWithParameters(string nameTransition, Dictionary<str
             _nextParameters = parameters;
         }
 
-        public void Start(Dictionary<string, object> startParameters = null)
+        private StateMachine InvokeTransition()
         {
+            //Mark nextParameters as current
+            _currentParameters = _nextParameters;
+            _nextParameters = null;
+
+            //Mark nextTransition as current
+            CurrentTransition = _nextTransition;
+            _nextTransition = null;
+
+            //Mark currentState as previous
+            PreviousState = CurrentState;
+            CurrentState = null;
+
+            
+            CurrentTransition.Invoke(_currentParameters);
+            CurrentState = CurrentTransition.StateTo;
+            CurrentTransition = null;
+
+            return this;
+        }
+
+        private StateMachine ChangeState()
+        {
+            CurrentState.Entry(_currentParameters);
+            _onChangeState?.Invoke(PreviousState, CurrentState);
+            CurrentState.Exit(_currentParameters);
+
+            return this;
+        }
+
+        public void Start(Dictionary<string, object> startParameters = null)
+        {        
             CurrentState = StartState;
-            CurrentState.Entry(startParameters);
-            _onChangeState?.Invoke(null, CurrentState);
-            CurrentState.Exit(startParameters);
+            _currentParameters = startParameters;
 
+            ChangeState();
 
             while (_nextTransition != null)
             {
-                _currentParameters = _nextParameters;
-                _nextParameters = null;
-
-                CurrentTransition = _nextTransition;
-                _nextTransition = null;
-
-                _beforeState = CurrentState;
-                CurrentState = null;
-                CurrentTransition.Invoke(_currentParameters);
-                CurrentState = CurrentTransition.StateTo;
-                CurrentTransition = null;
+                InvokeTransition();
 
-                CurrentState.Entry(_currentParameters);
-                _onChangeState?.Invoke(_beforeState, CurrentState);
-                CurrentState.Exit(_currentParameters);
+                ChangeState();
             }
 
         }

SimpleStateMachineLibrary/Transitions/Transition.cs

@@ -36,9 +36,11 @@ public Transition OnInvoke(Action<Transition, Dictionary<string, object>> action
             return this;
         }
 
-        internal void Invoke(Dictionary<string, object> parameters)
+        internal Transition Invoke(Dictionary<string, object> parameters)
         {
             _onInvoke?.Invoke (this, parameters);
+
+            return this;
         }