On the fly parameter cast

Author: haering

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -1277,6 +1277,32 @@ private void Evaluator_EvaluateVariable(object sender, VariableEvaluationEventAr
             }
         }
 
+        [TestCase("ClassForTest1.Add(1, 5)", ExpectedResult = 6, Category = "On the fly method")]
+        [TestCase("ClassForTest1.Add(1, 5.0)", ExpectedResult = 6, Category = "On the fly method")]
+        public object OnTheFlyEvaluation2(string expression)
+        {
+            ExpressionEvaluator evaluator = new ExpressionEvaluator(new ContextObject1());
+
+            evaluator.EvaluateParameterCast += Evaluator_EvaluateParameterCast;
+
+            evaluator.Namespaces.Add("CodingSeb.ExpressionEvaluator.Tests");
+
+            return evaluator.Evaluate(expression);
+        }
+
+        private void Evaluator_EvaluateParameterCast(object sender, ParameterCastEvaluationEventArg e)
+        {
+            if (e.ParameterType == typeof(ClassForTest2) && e.OriginalArg is int originalArgInt)
+            {
+                e.Argument = new ClassForTest2(originalArgInt);
+            }
+
+            if (e.ParameterType == typeof(ClassForTest2) && e.OriginalArg is double originalArgDouble)
+            {
+                e.Argument = new ClassForTest2((int) originalArgDouble);
+            }
+        }
+
         #endregion
 
         #endregion

CodingSeb.ExpressionEvaluator.Tests/TestsUtils/ClassForTest1.cs

@@ -26,5 +26,10 @@ public static string StaticStringMethod(string Name)
 
         public Func<int, int, int> AddAsDelegate { get; set; } = (nb1, nb2) => nb1 + nb2;
         public static Func<int, int, int> AddAsStaticDelegate { get; set; } = (nb1, nb2) => nb1 + nb2;
+
+        public static int Add(int a, ClassForTest2 b)
+        {
+            return a + b.Value1;
+        }
     }
 }

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -952,6 +952,12 @@ public IDictionary<string, object> Variables
         /// </summary>
         public event EventHandler<FunctionEvaluationEventArg> EvaluateFunction;
 
+        /// <summary>
+        /// Is fired when a parameter ist not the correct type for the function.
+        /// Allow to define a custom parameter cast for the function to work on the fly.
+        /// </summary>
+        public event EventHandler<ParameterCastEvaluationEventArg> EvaluateParameterCast;
+
         #endregion
 
         #region Constructors and overridable Inits methods
@@ -3333,7 +3339,25 @@ protected virtual MethodInfo TryToCastMethodParametersToMakeItCallable(MethodInf
                     }
                     catch
                     {
-                        parametersCastOK = false;
+                        try
+                        {
+                            ParameterCastEvaluationEventArg parameterCastEvaluationEventArg =
+                                new ParameterCastEvaluationEventArg(parameterType, modifiedArgs[a]);
+                            EvaluateParameterCast.Invoke(this, parameterCastEvaluationEventArg);
+                            if (parameterCastEvaluationEventArg.FunctionModifiedArgument)
+                            {
+                                modifiedArgs[a] = parameterCastEvaluationEventArg.Argument;
+                            }
+                            else
+                            {
+                                parametersCastOK = false;
+                            }
+                        }
+                        catch
+                        {
+                            parametersCastOK = false;
+                        }
+
                     }
                 }
             }
@@ -4377,5 +4401,53 @@ public FunctionPreEvaluationEventArg(string name, Func<string, object> evaluateF
         public bool CancelEvaluation { get; set; }
     }
 
+    /// <summary>
+    /// Class ParameterCastEvaluationEventArg.
+    /// Implements the <see cref="System.EventArgs" /></summary>
+    /// <seealso cref="System.EventArgs" />
+    public partial class ParameterCastEvaluationEventArg : EventArgs
+    {
+        /// <summary>
+        /// The required type of the parameter
+        /// </summary>
+        public Type ParameterType { get; }
+
+        /// <summary>
+        /// The original argument
+        /// </summary>
+        public object OriginalArg { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ParameterCastEvaluationEventArg" /> class.
+        /// </summary>
+        /// <param name="parameterType">Type of the parameter.</param>
+        /// <param name="originalArg">The original argument.</param>
+        public ParameterCastEvaluationEventArg(Type parameterType, object originalArg)
+        {
+            ParameterType = parameterType;
+            OriginalArg = originalArg;
+        }
+
+        private object modifiedArgument;
+
+        /// <summary>
+        /// To set the modified argument
+        /// </summary>
+        public object Argument
+        {
+            get { return modifiedArgument; }
+            set
+            {
+                modifiedArgument = value;
+                FunctionModifiedArgument = true;
+            }
+        }
+
+        /// <summary>
+        /// if <c>true</c> the argument has been modified, if <c>false</c> it means that the argument can't be of the given type.
+        /// </summary>
+        public bool FunctionModifiedArgument { get; set; }
+    }
+
     #endregion
 }