From b1c666af4c0d5b8061a9f048a5cc686481d73a32 Mon Sep 17 00:00:00 2001
From: Arnaud <arnaud.dev@gmail.com>
Date: Sun, 3 Mar 2019 08:28:09 +0100
Subject: [PATCH] Added async conditions support for If

---
 src/Automatonymous.Tests/Condition_Specs.cs   | 92 +++++++++++++++++++
 src/Automatonymous.Tests/Exception_Specs.cs   | 21 +++++
 .../Activities/ConditionActivity.cs           | 14 +--
 .../Activities/ConditionExceptionActivity.cs  | 14 +--
 .../Binders/CatchExceptionActivityBinder.cs   | 26 ++++++
 .../Binders/ConditionalActivityBinder.cs      | 16 +++-
 .../ConditionalExceptionActivityBinder.cs     | 17 +++-
 .../Binders/DataEventActivityBinder.cs        | 12 +++
 .../Binders/EventActivityBinder.cs            | 18 ++++
 .../Binders/ExceptionActivityBinder.cs        | 21 ++++-
 .../Binders/TriggerEventActivityBinder.cs     | 12 +++
 .../StateMachineAsyncCondition.cs             | 34 +++++++
 .../StateMachineAsyncExceptionCondition.cs    | 50 ++++++++++
 13 files changed, 326 insertions(+), 21 deletions(-)
 create mode 100644 src/Automatonymous/StateMachineAsyncCondition.cs
 create mode 100644 src/Automatonymous/StateMachineAsyncExceptionCondition.cs

diff --git a/src/Automatonymous.Tests/Condition_Specs.cs b/src/Automatonymous.Tests/Condition_Specs.cs
index f4470ee..6316925 100644
--- a/src/Automatonymous.Tests/Condition_Specs.cs
+++ b/src/Automatonymous.Tests/Condition_Specs.cs
@@ -104,6 +104,98 @@ class Start
         }
 
 
+        class StartedExplicitFilter
+        {
+        }
+    }
+
+    [TestFixture]
+    public class Using_an_async_condition_in_a_state_machine
+    {
+        [Test]
+        public async Task Should_allow_the_condition_to_be_used()
+        {
+            await _machine.RaiseEvent(_instance, _machine.Started, new Start {InitializeOnly = true});
+
+            Assert.That(_instance.CurrentState, Is.EqualTo(_machine.Initialized));
+        }
+
+        [Test]
+        public async Task Should_work()
+        {
+            await _machine.RaiseEvent(_instance, _machine.Started, new Start());
+
+            Assert.That(_instance.CurrentState, Is.EqualTo(_machine.Running));
+        }
+
+        [Test]
+        public async Task Should_allow_if_condition_to_be_evaluated()
+        {
+            await _machine.RaiseEvent(_instance, _machine.ExplicitFilterStarted, new StartedExplicitFilter());
+
+            Assert.That(_instance.CurrentState, Is.Not.EqualTo(_machine.ShouldNotBeHere));
+        }
+
+        [SetUp]
+        public void Specifying_an_event_activity()
+        {
+            _instance = new Instance();
+            _machine = new InstanceStateMachine();
+        }
+
+        Instance _instance;
+        InstanceStateMachine _machine;
+
+
+        class Instance
+        {
+            public bool InitializeOnly { get; set; }
+            public State CurrentState { get; set; }
+        }
+
+
+        class InstanceStateMachine :
+            AutomatonymousStateMachine<Instance>
+        {
+            public InstanceStateMachine()
+            {
+                During(Initial,
+                    When(Started)
+                        .Then(context => context.Instance.InitializeOnly = context.Data.InitializeOnly)
+                        .IfAsync(context => Task.FromResult(context.Data.InitializeOnly), x => x.Then(context => Console.WriteLine("Initializing Only!")))
+                        .TransitionTo(Initialized));
+
+                During(Initial,
+                    When(ExplicitFilterStarted, context => true)
+                        .IfAsync(context => Task.FromResult(false), binder => binder
+                            .Then(context => Console.WriteLine("Should not be here!"))
+                            .TransitionTo(ShouldNotBeHere))
+                        .IfAsync(context => Task.FromResult(true), binder => binder.Then(context => Console.WriteLine("Initializing Only!"))));
+
+                During(Running,
+                    When(Finish)
+                        .Finalize());
+
+                WhenEnter(Initialized, x => x.IfAsync(context => Task.FromResult(!context.Instance.InitializeOnly), b => b.TransitionTo(Running)));
+            }
+
+            public State Running { get; private set; }
+            public State Initialized { get; private set; }
+            public State ShouldNotBeHere { get; private set; }
+
+            public Event<Start> Started { get; private set; }
+            public Event<StartedExplicitFilter> ExplicitFilterStarted { get; private set; }
+
+            public Event Finish { get; private set; }
+        }
+
+
+        class Start
+        {
+            public bool InitializeOnly { get; set; }
+        }
+
+
         class StartedExplicitFilter
         {
         }
diff --git a/src/Automatonymous.Tests/Exception_Specs.cs b/src/Automatonymous.Tests/Exception_Specs.cs
index a5d766c..00ffc45 100644
--- a/src/Automatonymous.Tests/Exception_Specs.cs
+++ b/src/Automatonymous.Tests/Exception_Specs.cs
@@ -13,6 +13,7 @@
 namespace Automatonymous.Tests
 {
     using System;
+    using System.Threading.Tasks;
     using GreenPipes;
     using GreenPipes.Introspection;
     using NUnit.Framework;
@@ -50,6 +51,7 @@ public Instance()
             public bool ShouldNotBeCalled { get; set; }
 
             public bool CalledThenClause { get; set; }
+            public bool CalledSecondThenClause { get; set; }
         }
 
 
@@ -67,6 +69,9 @@ public InstanceStateMachine()
                             .If(context => true, b => b
                                 .Then(context => context.Instance.CalledThenClause = true)
                             )
+                            .IfAsync(context => Task.FromResult(true), b => b
+                                .Then(context => context.Instance.CalledSecondThenClause = true)
+                            )
                             .Then(context =>
                             {
                                 context.Instance.ExceptionMessage = context.Exception.Message;
@@ -133,6 +138,12 @@ public void Should_have_called_the_first_if_block()
         {
             Assert.IsTrue(_instance.CalledThenClause);
         }
+
+        [Test]
+        public void Should_have_called_the_async_if_block()
+        {
+            Assert.IsTrue(_instance.CalledSecondThenClause);
+        }
     }
 
     [TestFixture]
@@ -304,6 +315,7 @@ public Instance()
             public State CurrentState { get; set; }
 
             public bool CalledThenClause { get; set; }
+            public bool CalledSecondThenClause { get; set; }
         }
 
 
@@ -328,6 +340,9 @@ public InstanceStateMachine()
                             .If(context => true, b => b
                                 .Then(context => context.Instance.CalledThenClause = true)
                             )
+                            .IfAsync(context => Task.FromResult(true), b => b
+                                .Then(context => context.Instance.CalledSecondThenClause = true)
+                            )
                             .Then(context =>
                             {
                                 context.Instance.ExceptionMessage = context.Exception.Message;
@@ -377,5 +392,11 @@ public void Should_have_called_the_first_if_block()
         {
             Assert.IsTrue(_instance.CalledThenClause);
         }
+
+        [Test]
+        public void Should_have_called_the_async_if_block()
+        {
+            Assert.IsTrue(_instance.CalledSecondThenClause);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Activities/ConditionActivity.cs b/src/Automatonymous/Activities/ConditionActivity.cs
index 94f6b3a..4edf61c 100644
--- a/src/Automatonymous/Activities/ConditionActivity.cs
+++ b/src/Automatonymous/Activities/ConditionActivity.cs
@@ -21,9 +21,9 @@ public class ConditionActivity<TInstance> :
         where TInstance : class
     {
         readonly Behavior<TInstance> _behavior;
-        readonly StateMachineCondition<TInstance> _condition;
+        readonly StateMachineAsyncCondition<TInstance> _condition;
 
-        public ConditionActivity(StateMachineCondition<TInstance> condition, Behavior<TInstance> behavior)
+        public ConditionActivity(StateMachineAsyncCondition<TInstance> condition, Behavior<TInstance> behavior)
         {
             _condition = condition;
             _behavior = behavior;
@@ -43,7 +43,7 @@ void Visitable.Accept(StateMachineVisitor visitor)
 
         async Task Activity<TInstance>.Execute(BehaviorContext<TInstance> context, Behavior<TInstance> next)
         {
-            if (_condition(context))
+            if (await _condition(context).ConfigureAwait(false))
                 await _behavior.Execute(context).ConfigureAwait(false);
 
             await next.Execute(context).ConfigureAwait(false);
@@ -51,7 +51,7 @@ async Task Activity<TInstance>.Execute(BehaviorContext<TInstance> context, Behav
 
         async Task Activity<TInstance>.Execute<T>(BehaviorContext<TInstance, T> context, Behavior<TInstance, T> next)
         {
-            if (_condition(context))
+            if (await _condition(context).ConfigureAwait(false))
                 await _behavior.Execute(context).ConfigureAwait(false);
 
             await next.Execute(context).ConfigureAwait(false);
@@ -75,9 +75,9 @@ public class ConditionActivity<TInstance, TData> :
         where TInstance : class
     {
         readonly Behavior<TInstance> _behavior;
-        readonly StateMachineCondition<TInstance, TData> _condition;
+        readonly StateMachineAsyncCondition<TInstance, TData> _condition;
 
-        public ConditionActivity(StateMachineCondition<TInstance, TData> condition, Behavior<TInstance> behavior)
+        public ConditionActivity(StateMachineAsyncCondition<TInstance, TData> condition, Behavior<TInstance> behavior)
         {
             _condition = condition;
             _behavior = behavior;
@@ -105,7 +105,7 @@ async Task Activity<TInstance>.Execute<T>(BehaviorContext<TInstance, T> context,
             var behaviorContext = context as BehaviorContext<TInstance, TData>;
             if (behaviorContext != null)
             {
-                if (_condition(behaviorContext))
+                if (await _condition(behaviorContext).ConfigureAwait(false))
                     await _behavior.Execute(behaviorContext).ConfigureAwait(false);
             }
 
diff --git a/src/Automatonymous/Activities/ConditionExceptionActivity.cs b/src/Automatonymous/Activities/ConditionExceptionActivity.cs
index 019cd65..92446f1 100644
--- a/src/Automatonymous/Activities/ConditionExceptionActivity.cs
+++ b/src/Automatonymous/Activities/ConditionExceptionActivity.cs
@@ -23,9 +23,9 @@ public class ConditionExceptionActivity<TInstance, TConditionException> :
         where TConditionException : Exception
     {
         readonly Behavior<TInstance> _behavior;
-        readonly StateMachineExceptionCondition<TInstance, TConditionException> _condition;
+        readonly StateMachineAsyncExceptionCondition<TInstance, TConditionException> _condition;
 
-        public ConditionExceptionActivity(StateMachineExceptionCondition<TInstance, TConditionException> condition, Behavior<TInstance> behavior)
+        public ConditionExceptionActivity(StateMachineAsyncExceptionCondition<TInstance, TConditionException> condition, Behavior<TInstance> behavior)
         {
             _condition = condition;
             _behavior = behavior;
@@ -58,7 +58,7 @@ async Task Activity<TInstance>.Faulted<TException>(BehaviorExceptionContext<TIns
             var behaviorContext = context as BehaviorExceptionContext<TInstance, TConditionException>;
             if (behaviorContext != null)
             {
-                if (_condition(behaviorContext))
+                if (await _condition(behaviorContext).ConfigureAwait(false))
                 {
                     await _behavior.Faulted(context).ConfigureAwait(false);
                 }
@@ -73,7 +73,7 @@ async Task Activity<TInstance>.Faulted<T, TException>(BehaviorExceptionContext<T
             var behaviorContext = context as BehaviorExceptionContext<TInstance, T, TConditionException>;
             if (behaviorContext != null)
             {
-                if (_condition(behaviorContext))
+                if (await _condition(behaviorContext).ConfigureAwait(false))
                 {
                     await _behavior.Faulted(context).ConfigureAwait(false);
                 }
@@ -90,9 +90,9 @@ public class ConditionExceptionActivity<TInstance, TData, TConditionException> :
         where TConditionException : Exception
     {
         readonly Behavior<TInstance> _behavior;
-        readonly StateMachineExceptionCondition<TInstance, TData, TConditionException> _condition;
+        readonly StateMachineAsyncExceptionCondition<TInstance, TData, TConditionException> _condition;
 
-        public ConditionExceptionActivity(StateMachineExceptionCondition<TInstance, TData, TConditionException> condition, Behavior<TInstance> behavior)
+        public ConditionExceptionActivity(StateMachineAsyncExceptionCondition<TInstance, TData, TConditionException> condition, Behavior<TInstance> behavior)
         {
             _condition = condition;
             _behavior = behavior;
@@ -131,7 +131,7 @@ async Task Activity<TInstance>.Faulted<T, TException>(BehaviorExceptionContext<T
             var behaviorContext = context as BehaviorExceptionContext<TInstance, TData, TConditionException>;
             if (behaviorContext != null)
             {
-                if (_condition(behaviorContext))
+                if (await _condition(behaviorContext).ConfigureAwait(false))
                 {
                     await _behavior.Faulted(context).ConfigureAwait(false);
                 }
diff --git a/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs b/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs
index 5b3e0e6..bacb7ad 100644
--- a/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs
+++ b/src/Automatonymous/Binders/CatchExceptionActivityBinder.cs
@@ -86,6 +86,19 @@ public ExceptionActivityBinder<TInstance, TException> If(
 
             return new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event, _activities, conditionBinder);
         }
+
+        public ExceptionActivityBinder<TInstance, TException> IfAsync(
+            StateMachineAsyncExceptionCondition<TInstance, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> activityCallback)
+        {
+            ExceptionActivityBinder<TInstance, TException> binder = new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event);
+
+            binder = activityCallback(binder);
+
+            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TException>(_event, condition, binder);
+
+            return new CatchExceptionActivityBinder<TInstance, TException>(_machine, _event, _activities, conditionBinder);
+        }
     }
 
 
@@ -167,5 +180,18 @@ public ExceptionActivityBinder<TInstance, TData, TException> If(StateMachineExce
 
             return new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event, _activities, conditionBinder);
         }
+
+        public ExceptionActivityBinder<TInstance, TData, TException> IfAsync(StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> activityCallback)
+        {
+            ExceptionActivityBinder<TInstance, TData, TException> binder =
+                new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event);
+
+            binder = activityCallback(binder);
+
+            var conditionBinder = new ConditionalExceptionActivityBinder<TInstance, TData, TException>(_event, condition, binder);
+
+            return new CatchExceptionActivityBinder<TInstance, TData, TException>(_machine, _event, _activities, conditionBinder);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/ConditionalActivityBinder.cs b/src/Automatonymous/Binders/ConditionalActivityBinder.cs
index 29e458b..7608ce6 100644
--- a/src/Automatonymous/Binders/ConditionalActivityBinder.cs
+++ b/src/Automatonymous/Binders/ConditionalActivityBinder.cs
@@ -12,6 +12,7 @@
 // specific language governing permissions and limitations under the License.
 namespace Automatonymous.Binders
 {
+    using System.Threading.Tasks;
     using Activities;
     using Behaviors;
 
@@ -21,10 +22,15 @@ public class ConditionalActivityBinder<TInstance> :
         where TInstance : class
     {
         readonly EventActivities<TInstance> _activities;
-        readonly StateMachineCondition<TInstance> _condition;
+        readonly StateMachineAsyncCondition<TInstance> _condition;
         readonly Event _event;
 
         public ConditionalActivityBinder(Event @event, StateMachineCondition<TInstance> condition, EventActivities<TInstance> activities)
+            : this(@event, context => Task.FromResult(condition(context)), activities)
+        {
+        }
+
+        public ConditionalActivityBinder(Event @event, StateMachineAsyncCondition<TInstance> condition, EventActivities<TInstance> activities)
         {
             _activities = activities;
             _condition = condition;
@@ -72,11 +78,17 @@ public class ConditionalActivityBinder<TInstance, TData> :
         where TInstance : class
     {
         readonly EventActivities<TInstance> _activities;
-        readonly StateMachineCondition<TInstance, TData> _condition;
+        readonly StateMachineAsyncCondition<TInstance, TData> _condition;
         readonly Event _event;
 
         public ConditionalActivityBinder(Event @event, StateMachineCondition<TInstance, TData> condition,
             EventActivities<TInstance> activities)
+            : this(@event, context => Task.FromResult(condition(context)), activities)
+        {
+        }
+
+        public ConditionalActivityBinder(Event @event, StateMachineAsyncCondition<TInstance, TData> condition,
+            EventActivities<TInstance> activities)
         {
             _activities = activities;
             _condition = condition;
diff --git a/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs b/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs
index 3df49fc..9a82b35 100644
--- a/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs
+++ b/src/Automatonymous/Binders/ConditionalExceptionActivityBinder.cs
@@ -13,6 +13,7 @@
 namespace Automatonymous.Binders
 {
     using System;
+    using System.Threading.Tasks;
     using Activities;
     using Behaviors;
 
@@ -23,10 +24,15 @@ public class ConditionalExceptionActivityBinder<TInstance, TException> :
         where TException : Exception
     {
         readonly EventActivities<TInstance> _activities;
-        readonly StateMachineExceptionCondition<TInstance, TException> _condition;
+        readonly StateMachineAsyncExceptionCondition<TInstance, TException> _condition;
         readonly Event _event;
 
         public ConditionalExceptionActivityBinder(Event @event, StateMachineExceptionCondition<TInstance, TException> condition, EventActivities<TInstance> activities)
+            :this(@event, context => Task.FromResult(condition(context)), activities)
+        {
+        }
+
+        public ConditionalExceptionActivityBinder(Event @event, StateMachineAsyncExceptionCondition<TInstance, TException> condition, EventActivities<TInstance> activities)
         {
             _activities = activities;
             _condition = condition;
@@ -75,10 +81,15 @@ public class ConditionalExceptionActivityBinder<TInstance, TData, TException> :
         where TException : Exception
     {
         readonly EventActivities<TInstance> _activities;
-        readonly StateMachineExceptionCondition<TInstance, TData, TException> _condition;
+        readonly StateMachineAsyncExceptionCondition<TInstance, TData, TException> _condition;
         readonly Event _event;
 
-        public ConditionalExceptionActivityBinder(Event @event, StateMachineExceptionCondition<TInstance, TData, TException> condition,
+        public ConditionalExceptionActivityBinder(Event @event, StateMachineExceptionCondition<TInstance, TData, TException> condition, EventActivities<TInstance> activities)
+            : this(@event, context => Task.FromResult(condition(context)), activities)
+        {
+        }
+
+        public ConditionalExceptionActivityBinder(Event @event, StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
             EventActivities<TInstance> activities)
         {
             _activities = activities;
diff --git a/src/Automatonymous/Binders/DataEventActivityBinder.cs b/src/Automatonymous/Binders/DataEventActivityBinder.cs
index f80cebb..fa299b9 100644
--- a/src/Automatonymous/Binders/DataEventActivityBinder.cs
+++ b/src/Automatonymous/Binders/DataEventActivityBinder.cs
@@ -94,6 +94,18 @@ EventActivityBinder<TInstance, TData> EventActivityBinder<TInstance, TData>.If(S
             return new DataEventActivityBinder<TInstance, TData>(_machine, _event, _filter, _activities, conditionBinder);
         }
 
+        EventActivityBinder<TInstance, TData> EventActivityBinder<TInstance, TData>.IfAsync(StateMachineAsyncCondition<TInstance, TData> condition,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback)
+        {
+            EventActivityBinder<TInstance, TData> binder = new DataEventActivityBinder<TInstance, TData>(_machine, _event);
+
+            binder = activityCallback(binder);
+
+            var conditionBinder = new ConditionalActivityBinder<TInstance, TData>(_event, condition, binder);
+
+            return new DataEventActivityBinder<TInstance, TData>(_machine, _event, _filter, _activities, conditionBinder);
+        }
+
         StateMachine<TInstance> EventActivityBinder<TInstance, TData>.StateMachine => _machine;
 
         public IEnumerable<ActivityBinder<TInstance>> GetStateActivityBinders()
diff --git a/src/Automatonymous/Binders/EventActivityBinder.cs b/src/Automatonymous/Binders/EventActivityBinder.cs
index 49902c0..56c3f90 100644
--- a/src/Automatonymous/Binders/EventActivityBinder.cs
+++ b/src/Automatonymous/Binders/EventActivityBinder.cs
@@ -43,6 +43,15 @@ EventActivityBinder<TInstance> Catch<T>(
         /// <returns></returns>
         EventActivityBinder<TInstance> If(StateMachineCondition<TInstance> condition,
             Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="activityCallback"></param>
+        /// <returns></returns>
+        EventActivityBinder<TInstance> IfAsync(StateMachineAsyncCondition<TInstance> condition,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback);
     }
 
 
@@ -76,5 +85,14 @@ EventActivityBinder<TInstance, TData> Catch<T>(
         /// <returns></returns>
         EventActivityBinder<TInstance, TData> If(StateMachineCondition<TInstance, TData> condition,
             Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="activityCallback"></param>
+        /// <returns></returns>
+        EventActivityBinder<TInstance, TData> IfAsync(StateMachineAsyncCondition<TInstance, TData> condition,
+            Func<EventActivityBinder<TInstance, TData>, EventActivityBinder<TInstance, TData>> activityCallback);
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/ExceptionActivityBinder.cs b/src/Automatonymous/Binders/ExceptionActivityBinder.cs
index a0b7155..aaafe35 100644
--- a/src/Automatonymous/Binders/ExceptionActivityBinder.cs
+++ b/src/Automatonymous/Binders/ExceptionActivityBinder.cs
@@ -44,6 +44,15 @@ ExceptionActivityBinder<TInstance, TException> Catch<T>(
         /// <returns></returns>
         ExceptionActivityBinder<TInstance, TException> If(StateMachineExceptionCondition<TInstance, TException> condition,
             Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="activityCallback"></param>
+        /// <returns></returns>
+        ExceptionActivityBinder<TInstance, TException> IfAsync(StateMachineAsyncExceptionCondition<TInstance, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TException>, ExceptionActivityBinder<TInstance, TException>> activityCallback);
     }
 
 
@@ -77,7 +86,15 @@ ExceptionActivityBinder<TInstance, TData, TException> Catch<T>(
         /// <param name="activityCallback"></param>
         /// <returns></returns>
         ExceptionActivityBinder<TInstance, TData, TException> If(StateMachineExceptionCondition<TInstance, TData, TException> condition,
-            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>>
-                activityCallback);
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> activityCallback);
+
+        /// <summary>
+        /// Create a conditional branch of activities for processing
+        /// </summary>
+        /// <param name="condition"></param>
+        /// <param name="activityCallback"></param>
+        /// <returns></returns>
+        ExceptionActivityBinder<TInstance, TData, TException> IfAsync(StateMachineAsyncExceptionCondition<TInstance, TData, TException> condition,
+            Func<ExceptionActivityBinder<TInstance, TData, TException>, ExceptionActivityBinder<TInstance, TData, TException>> activityCallback);
     }
 }
\ No newline at end of file
diff --git a/src/Automatonymous/Binders/TriggerEventActivityBinder.cs b/src/Automatonymous/Binders/TriggerEventActivityBinder.cs
index b3d7edb..946f984 100644
--- a/src/Automatonymous/Binders/TriggerEventActivityBinder.cs
+++ b/src/Automatonymous/Binders/TriggerEventActivityBinder.cs
@@ -88,6 +88,18 @@ EventActivityBinder<TInstance> EventActivityBinder<TInstance>.If(StateMachineCon
             return new TriggerEventActivityBinder<TInstance>(_machine, _event, _filter, _activities, conditionBinder);
         }
 
+        EventActivityBinder<TInstance> EventActivityBinder<TInstance>.IfAsync(StateMachineAsyncCondition<TInstance> condition,
+            Func<EventActivityBinder<TInstance>, EventActivityBinder<TInstance>> activityCallback)
+        {
+            EventActivityBinder<TInstance> binder = new TriggerEventActivityBinder<TInstance>(_machine, _event);
+
+            binder = activityCallback(binder);
+
+            var conditionBinder = new ConditionalActivityBinder<TInstance>(_event, condition, binder);
+
+            return new TriggerEventActivityBinder<TInstance>(_machine, _event, _filter, _activities, conditionBinder);
+        }
+
         StateMachine<TInstance> EventActivityBinder<TInstance>.StateMachine => _machine;
 
         public IEnumerable<ActivityBinder<TInstance>> GetStateActivityBinders()
diff --git a/src/Automatonymous/StateMachineAsyncCondition.cs b/src/Automatonymous/StateMachineAsyncCondition.cs
new file mode 100644
index 0000000..4fdb6db
--- /dev/null
+++ b/src/Automatonymous/StateMachineAsyncCondition.cs
@@ -0,0 +1,34 @@
+// Copyright 2011-2019 Chris Patterson, Dru Sellers
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use 
+// this file except in compliance with the License. You may obtain a copy of the 
+// License at 
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+namespace Automatonymous
+{
+    using System.Threading.Tasks;
+
+
+    /// <summary>
+    /// Filters activities based on the async conditional statement
+    /// </summary>
+    /// <typeparam name="TInstance"></typeparam>
+    /// <param name="context"></param>
+    /// <returns></returns>
+    public delegate Task<bool> StateMachineAsyncCondition<in TInstance, in TData>(BehaviorContext<TInstance, TData> context);
+
+
+    /// <summary>
+    /// Filters activities based on the async conditional statement
+    /// </summary>
+    /// <typeparam name="TInstance"></typeparam>
+    /// <param name="context"></param>
+    /// <returns></returns>
+    public delegate Task<bool> StateMachineAsyncCondition<in TInstance>(BehaviorContext<TInstance> context);
+}
diff --git a/src/Automatonymous/StateMachineAsyncExceptionCondition.cs b/src/Automatonymous/StateMachineAsyncExceptionCondition.cs
new file mode 100644
index 0000000..fb4bfe1
--- /dev/null
+++ b/src/Automatonymous/StateMachineAsyncExceptionCondition.cs
@@ -0,0 +1,50 @@
+// Copyright 2011-2019 Chris Patterson, Dru Sellers
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use 
+// this file except in compliance with the License. You may obtain a copy of the 
+// License at 
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+// Copyright 2011-2019 Chris Patterson, Dru Sellers
+// 
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use 
+// this file except in compliance with the License. You may obtain a copy of the 
+// License at 
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0 
+// 
+// Unless required by applicable law or agreed to in writing, software distributed 
+// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
+// CONDITIONS OF ANY KIND, either express or implied. See the License for the 
+// specific language governing permissions and limitations under the License.
+namespace Automatonymous
+{
+    using System;
+    using System.Threading.Tasks;
+
+
+    /// <summary>
+    /// Filters activities based on the conditional statement
+    /// </summary>
+    /// <typeparam name="TInstance"></typeparam>
+    /// <typeparam name="TData"></typeparam>
+    /// <param name="context"></param>
+    /// <returns></returns>
+    public delegate Task<bool> StateMachineAsyncExceptionCondition<in TInstance, in TData, in TException>(BehaviorExceptionContext<TInstance, TData, TException> context)
+        where TException : Exception;
+
+
+    /// <summary>
+    /// Filters activities based on the conditional statement
+    /// </summary>
+    /// <typeparam name="TInstance"></typeparam>
+    /// <param name="context"></param>
+    /// <returns></returns>
+    public delegate Task<bool> StateMachineAsyncExceptionCondition<in TInstance, in TException>(BehaviorExceptionContext<TInstance, TException> context)
+        where TException : Exception;
+}
\ No newline at end of file