Refactor the CommandBase and ComCommandBase to be more smarter about executing the conditions on the OnExecute path by having a separate collection rather than re-using the whole collection of functions for CanExecute.

Author: bclothier

Rubberduck.Core/UI/Command/ComCommands/ComCommandBase.cs

@@ -9,14 +9,12 @@ public abstract class ComCommandBase : CommandBase
         protected ComCommandBase(IVbeEvents vbeEvents) 
         {
             _vbeEvents = vbeEvents;
-            AddToCanExecuteEvaluation(SpecialEvaluateCanExecute);
+            AddToCanExecuteEvaluation(SpecialEvaluateCanExecute, true);
         }
 
         private bool SpecialEvaluateCanExecute(object parameter)
         {
             return !_vbeEvents.Terminated;
         }
-
-        protected sealed override bool RequireReEvaluationOnExecute => true;
     }
 }

Rubberduck.Core/UI/Command/CommandBase.cs

@@ -22,16 +22,42 @@ protected CommandBase(ILogger logger = null)
         protected abstract void OnExecute(object parameter);
 
         protected Func<object, bool> CanExecuteCondition { get; private set; }
+        protected Func<object, bool> OnExecuteCondition { get; private set; }
+        private bool RequireReEvaluationOnExecute => OnExecuteCondition != null;
 
-        protected void AddToCanExecuteEvaluation(Func<object, bool> furtherCanExecuteEvaluation)
+        protected void AddToCanExecuteEvaluation(Func<object, bool> furtherCanExecuteEvaluation, bool requireReevaluation = false)
         {
             if (furtherCanExecuteEvaluation == null)
             {
                 return;
             }
 
-            var currentCanExecute = CanExecuteCondition;
-            CanExecuteCondition = (parameter) => currentCanExecute(parameter) && furtherCanExecuteEvaluation(parameter);
+            AddToCanExecuteEvaluation(furtherCanExecuteEvaluation);
+
+            if (requireReevaluation)
+            {
+                AddToOnExecuteEvaluation(furtherCanExecuteEvaluation);
+            }
+        }
+
+        private void AddToCanExecuteEvaluation(Func<object, bool> furtherCanExecuteEvaluation)
+        {
+            var currentCanExecuteCondition = CanExecuteCondition;
+            CanExecuteCondition = (parameter) =>
+                currentCanExecuteCondition(parameter) && furtherCanExecuteEvaluation(parameter);
+        }
+
+        private void AddToOnExecuteEvaluation(Func<object, bool> furtherCanExecuteEvaluation)
+        {
+            if (OnExecuteCondition == null)
+            {
+                OnExecuteCondition = furtherCanExecuteEvaluation;
+            }
+            else
+            {
+                var currentOnExecute = OnExecuteCondition;
+                OnExecuteCondition = (parameter) => currentOnExecute(parameter) && furtherCanExecuteEvaluation(parameter);
+            }
         }
 
         public bool CanExecute(object parameter)
@@ -53,15 +79,13 @@ public bool CanExecute(object parameter)
             }
         }
 
-        protected virtual bool RequireReEvaluationOnExecute => false;
-
         public void Execute(object parameter)
         {
             try
             {
                 if (RequireReEvaluationOnExecute)
                 {
-                    if (!CanExecute(parameter))
+                    if (!OnExecuteCondition(parameter))
                     {
                         return;
                     }