Fix #624, #704, #711, #714, #717: action exception propagation, list schema merging, OutputExpression error hint, global-param dedup, object-return diagnostics (#728)

* Fix #717, #711, #714, #704, #624: bug bash batch

#624: ActionBase.ExecuteAndReturnResultAsync silently captured every
exception into result.Exception regardless of EnableExceptionAsErrorMessage,
so an action throwing inside Run() never propagated when the setting was
false. Add ThrowIfActionExceptionShouldPropagate in RulesEngine to honor
the contract documented on ReSettings.

#711: OutputExpressionAction emitted a cryptic
"Expression is missing an 'as' clause" when users wrote C#-style anonymous
objects (`new { X = ... } as Result`). Detect the pattern and wrap the
parse exception with a clear hint pointing at the Dynamic.Core syntax
(`new (value as Name, ...)`).

#714: Global params were re-evaluated for every rule in the workflow,
so `Utils.FromDb(myInput)` ran N times per ExecuteAllRulesAsync call.
Move the global-params compilation+evaluation to workflow scope: compile
a single delegate at RegisterRule time, store it in RulesCache, evaluate
once in ExecuteAllRuleByWorkflow and append the result as RuleParameters
to each compiled rule. Preserve the existing per-rule error messages when
global compilation or evaluation fails. ExecuteActionWorkflowAsync
(which bypasses RulesCache) evaluates globals ad-hoc.

#704: Utils.CreateAbstractClassType used only list[0] when generating the
CLR type for a heterogeneous IList of ExpandoObject/Dictionary, so any
property appearing only in later elements was dropped. Walk every element
and union the schema; recursively merge nested dictionaries.

#717: Methods declared to return `object` cannot have their result
members accessed in Dynamic.Core expressions — the parser errors with
"exists in type 'Object'" or "is not defined for the types 'System.Object'".
We can't unbox at parse time, but the error message gave no clue what was
wrong. Detect those patterns in LambdaExpressionBuilder and append a
hint to change the method's return type to the concrete class.

All 144 tests pass on net6.0 / net8.0 / net9.0 / net10.0.

* Deduplicate helpers introduced in the batch fix

- RulesEngine.cs: ApplyGlobalParams and EvaluateGlobalsAdHoc both built
  RuleParameters from a globals delegate and concatenated them with the
  user's inputs. Extracted AppendGlobals (delegate-invoke + concat tail)
  and CompileGlobalParamsDelegate (GetRuleExpressionParameters + CompileScopedParams).

- Utils.cs: MergeListElementSchemas and MergeTwoDictionaries shared the
  same pair-merge logic. Replaced both with MergeDictionaries (n-ary fold)
  + MergeValues (handles dict/dict, list/list, and first-non-null fallback).
  The latter also makes nested list-concatenation consistent across all
  call sites.

No behavior change. All 144 tests still pass on net6/8/9/10.

---------

Co-authored-by: Yogesh Prajapati <yogeshcprajapati@outlook.com>

Author: YogeshPraj

src/RulesEngine/Actions/ExpressionOutputAction.cs

@@ -3,12 +3,18 @@
 
 using RulesEngine.ExpressionBuilders;
 using RulesEngine.Models;
+using System;
+using System.Linq.Dynamic.Core.Exceptions;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 namespace RulesEngine.Actions
 {
     public class OutputExpressionAction : ActionBase
     {
+        private static readonly Regex CSharpAnonymousObjectPattern =
+            new Regex(@"\bnew\s*\{", RegexOptions.Compiled);
+
         private readonly RuleExpressionParser _ruleExpressionParser;
 
         public OutputExpressionAction(RuleExpressionParser ruleExpressionParser)
@@ -19,7 +25,19 @@ public OutputExpressionAction(RuleExpressionParser ruleExpressionParser)
         public override ValueTask<object> Run(ActionContext context, RuleParameter[] ruleParameters)
         {
             var expression = context.GetContext<string>("expression");
-            return new ValueTask<object>(_ruleExpressionParser.Evaluate<object>(expression, ruleParameters));
+            try
+            {
+                return new ValueTask<object>(_ruleExpressionParser.Evaluate<object>(expression, ruleParameters));
+            }
+            catch (ParseException ex) when (CSharpAnonymousObjectPattern.IsMatch(expression ?? string.Empty))
+            {
+                throw new ParseException(
+                    "OutputExpression failed to parse. It looks like the expression uses C#-style anonymous-object syntax " +
+                    "(`new { Name = value, ... }`), which is not supported by System.Linq.Dynamic.Core. " +
+                    "Use the Dynamic.Core form instead: `new (value as Name, ...)` — parentheses, and each field needs an `as Alias`. " +
+                    "Original parser error: " + ex.Message,
+                    ex.Position);
+            }
         }
     }
 }

src/RulesEngine/ExpressionBuilders/LambdaExpressionBuilder.cs

@@ -34,11 +34,24 @@ internal override RuleFunc<RuleResultTree> BuildDelegateForRule(Rule rule, RuleP
             {
                 Helpers.HandleRuleException(ex,rule,_reSettings);
 
-                var exceptionMessage = Helpers.GetExceptionMessage($"Exception while parsing expression `{rule?.Expression}` - {ex.Message}",
+                var detail = ex.Message;
+                if (detail != null
+                    && (detail.Contains("exists in type 'Object'")
+                        || detail.Contains("'System.Object'"))
+                    && (rule?.Expression?.Contains('(') == true))
+                {
+                    // Dynamic.Core can only resolve members and operators against a static return type.
+                    // If a custom/static method's declared return type is `object`, member access or
+                    // operator usage on its result fails. See #717.
+                    detail += " (Hint: a method called in this expression appears to have an `object` return type. " +
+                              "Change its return type to the concrete class — Dynamic.Core cannot resolve members or operators on `object`.)";
+                }
+
+                var exceptionMessage = Helpers.GetExceptionMessage($"Exception while parsing expression `{rule?.Expression}` - {detail}",
                                                                     _reSettings);
 
                 bool func(object[] param) => false;
-                
+
                 return Helpers.ToResultTree(_reSettings, rule, null,func, exceptionMessage);
             }
         }

src/RulesEngine/HelperFunctions/Utils.cs

@@ -55,16 +55,7 @@ public static Type CreateAbstractClassType(dynamic input)
                 Type value;
                 if (expando.Value is IList list)
                 {
-                    if (list.Count == 0)
-                    {
-                        value = typeof(List<object>);
-                    }
-                    else
-                    {
-                        var internalType = CreateAbstractClassType(list[0]);
-                        value = new List<object>().Cast(internalType).ToList(internalType).GetType();
-                    }
-
+                    value = BuildListType(list);
                 }
                 else
                 {
@@ -77,6 +68,63 @@ public static Type CreateAbstractClassType(dynamic input)
             return type;
         }
 
+        // Returns the CLR List<T> type that should represent a heterogeneous IList of ExpandoObject /
+        // IDictionary<string, object> elements. Walks every element so properties that only appear in
+        // later elements are still included in the generated type. See #704.
+        private static Type BuildListType(IList list)
+        {
+            if (list.Count == 0)
+            {
+                return typeof(List<object>);
+            }
+
+            var firstElement = list[0];
+            if (firstElement is ExpandoObject || firstElement is IDictionary<string, object>)
+            {
+                var merged = MergeDictionaries(list.OfType<IDictionary<string, object>>());
+                var internalType = CreateAbstractClassTypeFromDictionary(merged);
+                return new List<object>().Cast(internalType).ToList(internalType).GetType();
+            }
+
+            // Non-schema-like element: fall back to first-element type as before.
+            var legacyType = CreateAbstractClassType(firstElement);
+            return new List<object>().Cast(legacyType).ToList(legacyType).GetType();
+        }
+
+        // Unions schemas from any number of dict-like inputs. Used both to merge sibling
+        // elements of a heterogeneous list (#704) and to merge nested dicts recursively.
+        private static IDictionary<string, object> MergeDictionaries(IEnumerable<IDictionary<string, object>> dictionaries)
+        {
+            var merged = new Dictionary<string, object>();
+            foreach (var dict in dictionaries)
+            {
+                foreach (var kvp in dict)
+                {
+                    merged[kvp.Key] = merged.TryGetValue(kvp.Key, out var existing)
+                        ? MergeValues(existing, kvp.Value)
+                        : kvp.Value;
+                }
+            }
+            return merged;
+        }
+
+        private static object MergeValues(object existing, object incoming)
+        {
+            if (existing is IDictionary<string, object> a && incoming is IDictionary<string, object> b)
+            {
+                return MergeDictionaries(new[] { a, b });
+            }
+            if (existing is IList la && incoming is IList lb)
+            {
+                var combined = new List<object>();
+                foreach (var e in la) combined.Add(e);
+                foreach (var e in lb) combined.Add(e);
+                return combined;
+            }
+            // First non-null wins on type conflict.
+            return existing ?? incoming;
+        }
+
         public static object CreateObject(Type type, dynamic input)
         {
             if (input is not ExpandoObject expandoObject)
@@ -152,17 +200,7 @@ private static Type CreateAbstractClassTypeFromDictionary(IDictionary<string, ob
                 }
                 else if (kvp.Value is IList list)
                 {
-                    if (list.Count == 0)
-                    {
-                        valueType = typeof(List<object>);
-                    }
-                    else
-                    {
-                        var internalType = list[0] is IDictionary<string, object> innerDict
-                            ? CreateAbstractClassTypeFromDictionary(innerDict)
-                            : (list[0] is ExpandoObject ? CreateAbstractClassType(list[0]) : list[0]?.GetType() ?? typeof(object));
-                        valueType = new List<object>().Cast(internalType).ToList(internalType).GetType();
-                    }
+                    valueType = BuildListType(list);
                 }
                 else
                 {

src/RulesEngine/RuleCompiler.cs

@@ -59,10 +59,10 @@ internal RuleFunc<RuleResultTree> CompileRule(Rule rule, RuleExpressionType rule
                 var globalParamExp = globalParams.Value;
                 var extendedRuleParams = ruleParams.Concat(globalParamExp.Select(c => new RuleParameter(c.ParameterExpression.Name,c.ParameterExpression.Type)))
                                                    .ToArray();
-                var ruleExpression = GetDelegateForRule(rule, extendedRuleParams);
-                
-
-                return GetWrappedRuleFunc(rule,ruleExpression,ruleParams,globalParamExp);
+                // Note: globals are no longer evaluated here per rule. The caller is expected
+                // to evaluate workflow-level globals once and pass them as extra RuleParameters
+                // when invoking the returned delegate. See #714.
+                return GetDelegateForRule(rule, extendedRuleParams);
             }
             catch (Exception ex)
             {

src/RulesEngine/RulesCache.cs

@@ -16,13 +16,29 @@ internal class RulesCache
         /// <summary>The compile rules</summary>
         private readonly MemCache _compileRules;
 
+        /// <summary>Per-workflow compiled delegate that evaluates all global params once.</summary>
+        private readonly MemCache _compiledGlobalParams;
+
         /// <summary>The workflow rules</summary>
         private readonly ConcurrentDictionary<string, (Workflow, long)> _workflow = new ConcurrentDictionary<string, (Workflow, long)>();
 
 
         public RulesCache(ReSettings reSettings)
         {
             _compileRules = new MemCache(reSettings.CacheConfig);
+            _compiledGlobalParams = new MemCache(reSettings.CacheConfig);
+        }
+
+        /// <summary>Adds or updates the workflow-level global-params delegate.</summary>
+        public void AddOrUpdateGlobalParamsDelegate(string compiledRuleKey, Func<object[], Dictionary<string, object>> globalParamsDelegate)
+        {
+            _compiledGlobalParams.Set(compiledRuleKey, globalParamsDelegate);
+        }
+
+        /// <summary>Gets the workflow-level global-params delegate, or null if the workflow has no globals.</summary>
+        public Func<object[], Dictionary<string, object>> GetGlobalParamsDelegate(string compiledRuleKey)
+        {
+            return _compiledGlobalParams.Get<Func<object[], Dictionary<string, object>>>(compiledRuleKey);
         }
 
 
@@ -81,6 +97,7 @@ public void Clear()
         {
             _workflow.Clear();
             _compileRules.Clear();
+            _compiledGlobalParams.Clear();
         }
 
         /// <summary>Gets the work flow rules.</summary>
@@ -133,10 +150,11 @@ public void Remove(string workflowName)
         {
             if (_workflow.TryRemove(workflowName, out var workflowObj))
             {
-                var compiledKeysToRemove = _compileRules.GetKeys().Where(key => key.StartsWith(workflowName));
+                var compiledKeysToRemove = _compileRules.GetKeys().Where(key => key.StartsWith(workflowName)).ToList();
                 foreach (var key in compiledKeysToRemove)
                 {
                     _compileRules.Remove(key);
+                    _compiledGlobalParams.Remove(key);
                 }
             }
         }