Add events ExpressionEvaluating and ExpressionEvaluated

Author: codingseb

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -992,7 +992,6 @@ public void TypeTesting(string expression, Type type)
 
         #endregion
 
-
         #endregion
         public object DirectExpressionEvaluation(string expression)
         {

CodingSeb.ExpressionEvaluator/CodingSeb.ExpressionEvaluator.csproj

@@ -19,8 +19,7 @@
     <PackageIconUrl>https://github.com/codingseb/ExpressionEvaluator/blob/master/Icon.png?raw=true</PackageIconUrl>
     <PackageIcon>Icon.png</PackageIcon>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
-    <PackageReleaseNotes>* Add the option OptionCanDeclareMultiExpressionsLambdaInSimpleExpressionEvaluate (default is true)
-* Allow to declare and call multi expressions lambda in simple expression Evaluate</PackageReleaseNotes>
+    <PackageReleaseNotes></PackageReleaseNotes>
     <PackageLicenseFile>LICENSE.md</PackageLicenseFile>
     <RepositoryUrl>https://github.com/codingseb/ExpressionEvaluator</RepositoryUrl>
   </PropertyGroup>

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -926,6 +926,18 @@ public IDictionary<string, object> Variables
             set { variables = value == null ? new Dictionary<string, object>(StringComparerForCasing) : new Dictionary<string, object>(value, StringComparerForCasing); }
         }
 
+        /// <summary>
+        /// Is fired just before an expression is evaluate.
+        /// Allow to redefine the expression to evaluate or to force a result value.
+        /// </summary>
+        public event EventHandler<ExpressionEvaluationEventArg> ExpressionEvaluating;
+
+        /// <summary>
+        /// Is fired just before to return the expression evaluation.
+        /// Allow to modify on the fly the result of the evaluation.
+        /// </summary>
+        public event EventHandler<ExpressionEvaluationEventArg> ExpressionEvaluated;
+
         /// <summary>
         /// Is fired before a variable, field or property resolution.
         /// Allow to define a variable and the corresponding value on the fly.
@@ -1564,25 +1576,51 @@ public object Evaluate(string expression)
 
             Stack<object> stack = new Stack<object>();
             evaluationStackCount++;
+            object result;
+
             try
             {
-                if (GetLambdaExpression(expression, stack))
-                    return stack.Pop();
+                ExpressionEvaluationEventArg expressionEvaluationEventArg = new ExpressionEvaluationEventArg(expression, this);
 
-                for (int i = 0; i < expression.Length; i++)
+                ExpressionEvaluating?.Invoke(this, expressionEvaluationEventArg);
+
+                expression = expressionEvaluationEventArg.Expression;
+
+                if (expressionEvaluationEventArg.HasValue)
                 {
-                    if (!ParsingMethods.Any(parsingMethod => parsingMethod(expression, stack, ref i)))
-                    {
-                        string s = expression.Substring(i, 1);
+                    result = expressionEvaluationEventArg.Value;
+                }
+                else
+                {
+                    if (GetLambdaExpression(expression, stack))
+                        return stack.Pop();
 
-                        if (!s.Trim().Equals(string.Empty))
+                    for (int i = 0; i < expression.Length; i++)
+                    {
+                        if (!ParsingMethods.Any(parsingMethod => parsingMethod(expression, stack, ref i)))
                         {
-                            throw new ExpressionEvaluatorSyntaxErrorException($"Invalid character [{(int)s[0]}:{s}]");
+                            string s = expression.Substring(i, 1);
+
+                            if (!s.Trim().Equals(string.Empty))
+                            {
+                                throw new ExpressionEvaluatorSyntaxErrorException($"Invalid character [{(int)s[0]}:{s}]");
+                            }
                         }
                     }
+
+                    result = ProcessStack(stack);
+
+                    expressionEvaluationEventArg = new ExpressionEvaluationEventArg(expression, this, result);
+
+                    ExpressionEvaluated?.Invoke(this, expressionEvaluationEventArg);
+
+                    if (expressionEvaluationEventArg.HasValue)
+                    {
+                        result = expressionEvaluationEventArg.Value;
+                    }
                 }
 
-                return ProcessStack(stack);
+                return result;
             }
             finally
             {
@@ -3015,6 +3053,7 @@ protected virtual object ProcessStack(Stack<object> stack)
 
             return stack.Pop();
         }
+
         #endregion
 
         #region Remove comments
@@ -4292,6 +4331,50 @@ public Type[] EvaluateGenericTypes()
         }
     }
 
+    public partial class ExpressionEvaluationEventArg : EventArgs
+    {
+        private object value;
+
+        public ExpressionEvaluationEventArg(string expression, ExpressionEvaluator evaluator)
+        {
+            Expression = expression;
+            Evaluator = evaluator;
+        }
+
+        public ExpressionEvaluationEventArg(string expression, ExpressionEvaluator evaluator, object value)
+        {
+            Expression = expression;
+            Evaluator = evaluator;
+            this.value = value;
+        }
+
+        public ExpressionEvaluator Evaluator { get; }
+
+        /// <summary>
+        /// The Expression that wil be evaluated.
+        /// Can be modified.
+        /// </summary>
+        public string Expression { get; set; }
+
+        /// <summary>
+        /// To set the return of the evaluation
+        /// </summary>
+        public object Value
+        {
+            get { return value; }
+            set
+            {
+                this.value = value;
+                HasValue = true;
+            }
+        }
+
+        /// <summary>
+        /// if <c>true</c> the expression evaluation has been done, if <c>false</c> it means that the evaluation must continue.
+        /// </summary>
+        public bool HasValue { get; set; }
+    }
+
     /// <summary>
     /// Infos about the variable, attribut or property that is currently evaluate
     /// </summary>
@@ -4433,7 +4516,6 @@ public FunctionPreEvaluationEventArg(string name, List<string> args = null, Expr
         public bool CancelEvaluation { get; set; }
     }
 
-
     /// <summary>
     /// Infos about the indexing that is currently evaluate
     /// </summary>