Even more fluent syntax

.editorconfig

@@ -0,0 +1,88 @@
+# Rules in this file were initially inferred by Visual Studio IntelliCode from the C:\Users\henning.torsteinsen\source\repos\stateless\HenningNTStateless codebase based on best match to current usage at 14.04.2020
+# You can modify the rules from these initially generated values to suit your own policies
+# You can learn more about editorconfig here: https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference
+[*.cs]
+
+#Core editorconfig formatting - indentation
+
+#use soft tabs (spaces) for indentation
+indent_style = space
+
+#Formatting - new line options
+
+#place else statements on a new line
+csharp_new_line_before_else = true
+#require braces to be on a new line for control_blocks, methods, properties, lambdas, types, and accessors (also known as "Allman" style)
+csharp_new_line_before_open_brace = control_blocks, methods, properties, lambdas, types, accessors
+
+#Formatting - organize using options
+
+#sort System.* using directives alphabetically, and place them before other usings
+dotnet_sort_system_directives_first = true
+
+#Formatting - spacing options
+
+#require NO space between a cast and the value
+csharp_space_after_cast = false
+#require a space before the colon for bases or interfaces in a type declaration
+csharp_space_after_colon_in_inheritance_clause = true
+#require a space after a keyword in a control flow statement such as a for loop
+csharp_space_after_keywords_in_control_flow_statements = true
+#require a space before the colon for bases or interfaces in a type declaration
+csharp_space_before_colon_in_inheritance_clause = true
+#remove space within empty argument list parentheses
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+#remove space between method call name and opening parenthesis
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+#do not place space characters after the opening parenthesis and before the closing parenthesis of a method call
+csharp_space_between_method_call_parameter_list_parentheses = false
+#remove space within empty parameter list parentheses for a method declaration
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+#place a space character after the opening parenthesis and before the closing parenthesis of a method declaration parameter list.
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+
+#Formatting - wrapping options
+
+#leave code block on single line
+csharp_preserve_single_line_blocks = true
+#leave statements and member declarations on the same line
+csharp_preserve_single_line_statements = true
+
+#Style - expression bodied member options
+
+#prefer block bodies for accessors
+csharp_style_expression_bodied_accessors = false:suggestion
+#prefer block bodies for constructors
+csharp_style_expression_bodied_constructors = false:suggestion
+#prefer block bodies for methods
+csharp_style_expression_bodied_methods = false:suggestion
+#prefer block bodies for properties
+csharp_style_expression_bodied_properties = false:suggestion
+
+#Style - expression level options
+
+#prefer out variables to be declared inline in the argument list of a method call when possible
+csharp_style_inlined_variable_declaration = true:suggestion
+#prefer the language keyword for member access expressions, instead of the type name, for types that have a keyword to represent them
+dotnet_style_predefined_type_for_member_access = true:suggestion
+
+#Style - implicit and explicit types
+
+#prefer var is used to declare variables with built-in system types such as int
+csharp_style_var_for_built_in_types = true:suggestion
+#prefer var when the type is already mentioned on the right-hand side of a declaration expression
+csharp_style_var_when_type_is_apparent = true:suggestion
+
+#Style - language keyword and framework type options
+
+#prefer the language keyword for local variables, method parameters, and class members, instead of the type name, for types that have a keyword to represent them
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+
+#Style - qualification options
+
+#prefer fields not to be prefaced with this. or Me. in Visual Basic
+dotnet_style_qualification_for_field = false:suggestion
+#prefer methods not to be prefaced with this. or Me. in Visual Basic
+dotnet_style_qualification_for_method = false:suggestion
+#prefer properties not to be prefaced with this. or Me. in Visual Basic
+dotnet_style_qualification_for_property = false:suggestion

Stateless.sln

@@ -38,6 +38,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TelephoneCallExample", "exa
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JsonExample", "example\JsonExample\JsonExample.csproj", "{809A7873-DD78-4D5D-A432-9718C929BECA}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{B500BE05-347F-4BD8-8FB4-A24C08CFA610}"
+	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

example/BugTrackerExample/Bug.cs

@@ -34,21 +34,21 @@ public Bug(string title)
 
             // Configure the Open state
             _machine.Configure(State.Open)
-                .Permit(Trigger.Assign, State.Assigned);
+                .Transition(Trigger.Assign).To(State.Assigned);
 
             // Configure the Assigned state
             _machine.Configure(State.Assigned)
                 .SubstateOf(State.Open)
+                .OnExit(OnDeassigned)
                 .OnEntryFrom(_assignTrigger, OnAssigned)  // This is where the TriggerWithParameters is used. Note that the TriggerWithParameters object is used, not something from the enum
-                .PermitReentry(Trigger.Assign)
-                .Permit(Trigger.Close, State.Closed)
-                .Permit(Trigger.Defer, State.Deferred)
-                .OnExit(OnDeassigned);
+                .Transition(Trigger.Assign).Self()
+                .Transition(Trigger.Close).To(State.Closed)
+                .Transition(Trigger.Defer).To(State.Deferred);
 
             // Configure the Deferred state
             _machine.Configure(State.Deferred)
                 .OnEntry(() => _assignee = null)
-                .Permit(Trigger.Assign, State.Assigned);
+                .Transition(Trigger.Assign).To(State.Assigned);
         }
 
         public void Close()

example/JsonExample/Member.cs

@@ -33,7 +33,7 @@ public Member(string name)
         [JsonConstructor]
         private Member(string state, string name)
         {
-            var memberState = (MembershipState) Enum.Parse(typeof(MembershipState), state);
+            var memberState = (MembershipState)Enum.Parse(typeof(MembershipState), state);
             _stateMachine = new StateMachine<MembershipState, MemberTriggers>(memberState);
             Name = name;
 
@@ -43,15 +43,15 @@ private Member(string state, string name)
         private void ConfigureStateMachine()
         {
             _stateMachine.Configure(MembershipState.Active)
-                .Permit(MemberTriggers.Suspend, MembershipState.Inactive)
-                .Permit(MemberTriggers.Terminate, MembershipState.Terminated);
+                .Transition(MemberTriggers.Suspend).To(MembershipState.Inactive)
+                .Transition(MemberTriggers.Terminate).To(MembershipState.Terminated);
 
             _stateMachine.Configure(MembershipState.Inactive)
-                .Permit(MemberTriggers.Reactivate, MembershipState.Active)
-                .Permit(MemberTriggers.Terminate, MembershipState.Terminated);
+                .Transition(MemberTriggers.Reactivate).To(MembershipState.Active)
+                .Transition(MemberTriggers.Terminate).To(MembershipState.Terminated);
 
             _stateMachine.Configure(MembershipState.Terminated)
-                .Permit(MemberTriggers.Reactivate, MembershipState.Active);
+                .Transition(MemberTriggers.Reactivate).To(MembershipState.Active);
         }
 
         public void Terminate()
@@ -86,6 +86,6 @@ public bool Equals(Member anotherMember)
     }
 
 
-    
+
 
 }

example/OnOffExample/Program.cs

@@ -19,16 +19,16 @@ static void Main(string[] args)
             var onOffSwitch = new StateMachine<string, char>(off);
 
             // Configure state machine with the Configure method, supplying the state to be configured as a parameter
-            onOffSwitch.Configure(off).Permit(space, on);
-            onOffSwitch.Configure(on).Permit(space, off);
+            onOffSwitch.Configure(off).Transition(space).To(on);
+            onOffSwitch.Configure(on).Transition(space).To(off);
 
             Console.WriteLine("Press <space> to toggle the switch. Any other key will exit the program.");
 
             while (true)
             {
                 Console.WriteLine("Switch is in state: " + onOffSwitch.State);
                 var pressed = Console.ReadKey(true).KeyChar;
-                
+
                 // Check if user wants to exit
                 if (pressed != space) break;
 

example/TelephoneCallExample/PhoneCall.cs

@@ -48,25 +48,25 @@ public PhoneCall(string caller)
             _setCalleeTrigger = _machine.SetTriggerParameters<string>(Trigger.CallDialed);
 
             _machine.Configure(State.OffHook)
-	            .Permit(Trigger.CallDialed, State.Ringing);
+	            .Transition(Trigger.CallDialed).To(State.Ringing);
 
             _machine.Configure(State.Ringing)
                 .OnEntryFrom(_setCalleeTrigger, callee => OnDialed(callee), "Caller number to call")
-	            .Permit(Trigger.CallConnected, State.Connected);
+	            .Transition(Trigger.CallConnected).To(State.Connected);
 
             _machine.Configure(State.Connected)
                 .OnEntry(t => StartCallTimer())
                 .OnExit(t => StopCallTimer())
-                .InternalTransition(Trigger.MuteMicrophone, t => OnMute())
-                .InternalTransition(Trigger.UnmuteMicrophone, t => OnUnmute())
-                .InternalTransition<int>(_setVolumeTrigger, (volume, t) => OnSetVolume(volume))
-                .Permit(Trigger.LeftMessage, State.OffHook)
-	            .Permit(Trigger.PlacedOnHold, State.OnHold);
+                .Transition(Trigger.MuteMicrophone).Internal().Do(() => OnMute())
+                .Transition(Trigger.UnmuteMicrophone).Internal().Do( () => OnUnmute())
+                .Transition(Trigger.SetVolume).Internal().Do<int>( (volume, t) => OnSetVolume(volume))
+                .Transition(Trigger.LeftMessage).To(State.OffHook)
+	            .Transition(Trigger.PlacedOnHold).To(State.OnHold);
 
             _machine.Configure(State.OnHold)
                 .SubstateOf(State.Connected)
-                .Permit(Trigger.TakenOffHold, State.Connected)
-                .Permit(Trigger.PhoneHurledAgainstWall, State.PhoneDestroyed);
+                .Transition(Trigger.TakenOffHold).To(State.Connected)
+                .Transition(Trigger.PhoneHurledAgainstWall).To(State.PhoneDestroyed);
 
             _machine.OnTransitioned(t => Console.WriteLine($"OnTransitioned: {t.Source} -> {t.Destination} via {t.Trigger}({string.Join(", ",  t.Parameters)})"));
         }

src/Stateless/DestinationConfiguration.cs

@@ -0,0 +1,93 @@
+using System;
+
+namespace Stateless
+{
+    partial class StateMachine<TState, TTrigger>
+    {
+        /// <summary>
+        /// This class containd the required trigger information for a transition.
+        /// </summary>
+        public class DestinationConfiguration
+        {
+            private readonly TransitionConfiguration _transitionConfiguration;
+            private readonly TriggerBehaviour _triggerBehaviour;
+            private readonly StateRepresentation _representation;
+
+            internal DestinationConfiguration(TransitionConfiguration transitionConfiguration, TriggerBehaviour triggerBehaviour, StateRepresentation representation)
+            {
+                _transitionConfiguration = transitionConfiguration;
+                _triggerBehaviour = triggerBehaviour;
+                _representation = representation;
+            }
+
+            /// <summary>
+            /// Adds a guard function to the trigger. This guard function will determine if the transition will occur or not.
+            /// </summary>
+            /// <param name="guard">This method is run when the state machine fires the trigger.</param>
+            /// <param name="description">Optional description of the guard</param>
+            public DestinationConfiguration If(Func<object[], bool> guard, string description = null)
+            {
+                _triggerBehaviour.SetGuard(new TransitionGuard(guard, description));
+                return this;
+            }
+
+            /// <summary>
+            /// Adds a guard function to the trigger. This guard function will determine if the transition will occur or not.
+            /// </summary>
+            /// <typeparam name="TArg">The parameter to the guard function </typeparam>
+            /// <param name="guard">This method is run when the state machine fires the trigger.</param>
+            /// <param name="description">Optional description of the guard</param>
+            public DestinationConfiguration If<TArg>(Func<TArg, bool> guard, string description = null)
+            {
+                _triggerBehaviour.SetGuard(new TransitionGuard(TransitionGuard.ToPackedGuard(guard), description));
+                return this;
+            }
+
+            /// <summary>
+            /// Creates a new transition. Use To(), Self(), Internal() or Dynamic() to set up the destination.
+            /// </summary>
+            /// <param name="trigger">The event trigger that will trigger this transition.</param>
+            public TransitionConfiguration Transition(TTrigger trigger)
+            {
+                return new TransitionConfiguration(_transitionConfiguration.StateConfiguration, _representation, trigger);
+            }
+
+            /// <summary>
+            /// Adds an action to a transition. The action will be executed before the Exit action(s) (if any) are executed.
+            /// </summary>
+            /// <param name="someAction">The action run when the trigger event is handled.</param>
+            public StateConfiguration Do(Action someAction)
+            {
+                if (someAction == null) throw new ArgumentNullException(nameof(someAction));
+
+                _triggerBehaviour.AddAction((t, args) => someAction());
+                return _transitionConfiguration.StateConfiguration;
+            }
+
+            /// <summary>
+            /// Adds an action to a transition. The action will be executed before the Exit action(s) (if any) are executed.
+            /// </summary>
+            /// <param name="someAction">The action run when the trigger event is handled.</param>
+            public StateConfiguration Do(Action<Transition> someAction)
+            {
+                if (someAction == null) throw new ArgumentNullException(nameof(someAction));
+
+                _triggerBehaviour.AddAction(someAction);
+                return _transitionConfiguration.StateConfiguration;
+            }
+
+            /// <summary>
+            /// Adds an action to a transition. The action will be executed before the Exit action(s) (if any) are executed.
+            /// </summary>
+            /// <typeparam name="TArg">The paramter used by the action.</typeparam>
+            /// <param name="someAction">The action run when the trigger event is handled.</param>
+            public StateConfiguration Do<TArg>(Action<TArg, Transition> someAction)
+            {
+                if (someAction == null) throw new ArgumentNullException(nameof(someAction));
+
+                _triggerBehaviour.AddAction((t, args) => someAction(ParameterConversion.Unpack<TArg>(args, 0), t));
+                return _transitionConfiguration.StateConfiguration;
+            }
+        }
+    }
+}

src/Stateless/StateConfiguration.Async.cs

@@ -9,6 +9,8 @@ public partial class StateMachine<TState, TTrigger>
     {
         public partial class StateConfiguration
         {
+
+
             /// <summary>
             /// Add an internal transition to the state machine. An internal action does not cause the Exit and Entry actions to be triggered, and does not change the state of the state machine
             /// </summary>

src/Stateless/StateConfiguration.cs

@@ -1710,6 +1710,15 @@ public StateConfiguration InitialTransition(TState targetState)
                 _representation.SetInitialTransition(targetState);
                 return this;
             }
+
+            /// <summary>
+            /// Creates a new transition. Use To(), Self(), Internal() or Dynamic() to set up the destination.
+            /// </summary>
+            /// <param name="trigger">The event trigger that will trigger this transition.</param>
+            public TransitionConfiguration Transition(TTrigger trigger)
+            {
+                return new TransitionConfiguration(this, _representation, trigger);
+            }
         }
     }
 }

src/Stateless/StateMachine.cs

@@ -369,6 +369,12 @@ void InternalFireOne(TTrigger trigger, params object[] args)
                 {
                     // Handle transition, and set new state
                     var transition = new Transition(source, handler.Destination, trigger, args);
+
+                    // If trigger handler has action, execute it
+                    if (result.Handler.HasAction())
+                    {
+                        result.Handler.ExecuteAction(transition, args);
+                    }
                     HandleReentryTrigger(args, representativeState, transition);
                     break;
                 }
@@ -377,15 +383,25 @@ void InternalFireOne(TTrigger trigger, params object[] args)
                 {
                     // Handle transition, and set new state
                     var transition = new Transition(source, destination, trigger, args);
-                    HandleTransitioningTrigger(args, representativeState, transition);
+                        // If trigger handler has action, execute it
+                        if (result.Handler.HasAction())
+                        {
+                            result.Handler.ExecuteAction(transition, args);
+                        }
+                        HandleTransitioningTrigger(args, representativeState, transition);
 
                     break;
                 }
                 case InternalTriggerBehaviour _:
                 {
                     // Internal transitions does not update the current state, but must execute the associated action.
                     var transition = new Transition(source, source, trigger, args);
-                    CurrentRepresentation.InternalAction(transition, args);
+                        // If trigger handler has action, execute it
+                        if (result.Handler.HasAction())
+                        {
+                            result.Handler.ExecuteAction(transition, args);
+                        }
+                        CurrentRepresentation.InternalAction(transition, args);
                     break;
                 }
                 default: