Introduce Sliding Cache to Constant Expression Helper

src/System.Linq.Dynamic.Core/Parser/ConstantExpressionHelper.cs

@@ -1,29 +1,40 @@
-using System.Collections.Concurrent;
+using System.Linq.Dynamic.Core.Util.Cache;
+using System.Linq.Dynamic.Core.Validation;
 using System.Linq.Expressions;
 
-namespace System.Linq.Dynamic.Core.Parser
+namespace System.Linq.Dynamic.Core.Parser;
+
+internal class ConstantExpressionHelper
 {
-    internal static class ConstantExpressionHelper
+    private readonly SlidingCache<object, Expression> _expressions;
+    private readonly SlidingCache<Expression, string> _literals;
+
+    public ConstantExpressionHelper(ParsingConfig config)
+    {
+        var parsingConfig = Check.NotNull(config);
+        var useConfig = parsingConfig.ConstantExpressionCacheConfig ?? new CacheConfig();
+
+        _literals = new SlidingCache<Expression, string>(useConfig);
+        _expressions = new SlidingCache<object, Expression>(useConfig);
+    }
+
+    public bool TryGetText(Expression expression, out string? text)
     {
-        private static readonly ConcurrentDictionary<object, Expression> Expressions = new();
-        private static readonly ConcurrentDictionary<Expression, string> Literals = new();
+        return _literals.TryGetValue(expression, out text);
+    }
 
-        public static bool TryGetText(Expression expression, out string? text)
+    public Expression CreateLiteral(object value, string text)
+    {
+        if (_expressions.TryGetValue(value, out var outputValue))
         {
-            return Literals.TryGetValue(expression, out text);
+            return outputValue;
         }
 
-        public static Expression CreateLiteral(object value, string text)
-        {
-            if (!Expressions.ContainsKey(value))
-            {
-                ConstantExpression constantExpression = Expression.Constant(value);
+        var constantExpression = Expression.Constant(value);
 
-                Expressions.TryAdd(value, constantExpression);
-                Literals.TryAdd(constantExpression, text);
-            }
+        _expressions.AddOrUpdate(value, constantExpression);
+        _literals.AddOrUpdate(constantExpression, text);
 
-            return Expressions[value];
-        }
+        return constantExpression;
     }
 }

src/System.Linq.Dynamic.Core/Parser/ConstantExpressionHelperFactory.cs

@@ -0,0 +1,20 @@
+namespace System.Linq.Dynamic.Core.Parser;
+
+internal static class ConstantExpressionHelperFactory
+{
+    private static readonly object Lock = new();
+    private static ConstantExpressionHelper? _instance;
+
+    public static ConstantExpressionHelper GetInstance(ParsingConfig config)
+    {
+        if (_instance == null)
+        {
+            lock (Lock)
+            {
+                _instance ??= new ConstantExpressionHelper(config);
+            }
+        }
+
+        return _instance;
+    }
+}

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -45,6 +45,7 @@ public class ExpressionParser
     private ParameterExpression? _root;
     private Type? _resultType;
     private bool _createParameterCtor;
+    private ConstantExpressionHelper _constantExpressionHelper;
 
     /// <summary>
     /// Gets name for the `it` field. By default this is set to the KeyWord value "it".
@@ -81,6 +82,7 @@ public ExpressionParser(ParameterExpression[]? parameters, string expression, ob
         _methodFinder = new MethodFinder(_parsingConfig, _expressionHelper);
         _typeFinder = new TypeFinder(_parsingConfig, _keywordsHelper);
         _typeConverterFactory = new TypeConverterFactory(_parsingConfig);
+        _constantExpressionHelper = ConstantExpressionHelperFactory.GetInstance(_parsingConfig);
 
         if (parameters != null)
         {
@@ -900,7 +902,7 @@ private AnyOf<Expression, Type> ParseStringLiteral(bool forceParseAsString)
             }
 
             _textParser.NextToken();
-            return ConstantExpressionHelper.CreateLiteral(parsedStringValue[0], parsedStringValue);
+            return _constantExpressionHelper.CreateLiteral(parsedStringValue[0], parsedStringValue);
         }
 
         _textParser.NextToken();
@@ -924,7 +926,7 @@ private AnyOf<Expression, Type> ParseStringLiteral(bool forceParseAsString)
 
         parsedStringValue = StringParser.ParseStringAndReplaceDoubleQuotes(text, _textParser.CurrentToken.Pos);
 
-        return ConstantExpressionHelper.CreateLiteral(parsedStringValue, parsedStringValue);
+        return _constantExpressionHelper.CreateLiteral(parsedStringValue, parsedStringValue);
     }
 
     private Expression ParseIntegerLiteral()

src/System.Linq.Dynamic.Core/Parser/ExpressionPromoter.cs

@@ -9,6 +9,7 @@ namespace System.Linq.Dynamic.Core.Parser
     public class ExpressionPromoter : IExpressionPromoter
     {
         private readonly NumberParser _numberParser;
+        private readonly ConstantExpressionHelper _constantExpressionHelper;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ExpressionPromoter"/> class.
@@ -17,6 +18,7 @@ public class ExpressionPromoter : IExpressionPromoter
         public ExpressionPromoter(ParsingConfig config)
         {
             _numberParser = new NumberParser(config);
+            _constantExpressionHelper = ConstantExpressionHelperFactory.GetInstance(config);
         }
 
         /// <inheritdoc />
@@ -48,7 +50,7 @@ public ExpressionPromoter(ParsingConfig config)
                 }
                 else
                 {
-                    if (ConstantExpressionHelper.TryGetText(ce, out var text))
+                    if (_constantExpressionHelper.TryGetText(ce, out var text))
                     {
                         Type target = TypeHelper.GetNonNullableType(type);
                         object? value = null;

src/System.Linq.Dynamic.Core/Parser/NumberParser.cs

@@ -16,6 +16,7 @@ public class NumberParser
         private static readonly char[] Qualifiers = { 'U', 'u', 'L', 'l', 'F', 'f', 'D', 'd', 'M', 'm' };
         private static readonly char[] QualifiersHex = { 'U', 'u', 'L', 'l' };
         private static readonly string[] QualifiersReal = { "F", "f", "D", "d", "M", "m" };
+        private readonly ConstantExpressionHelper _constantExpressionHelper;
 
         private readonly CultureInfo _culture;
 
@@ -26,6 +27,7 @@ public class NumberParser
         public NumberParser(ParsingConfig? config)
         {
             _culture = config?.NumberParseCulture ?? CultureInfo.InvariantCulture;
+            _constantExpressionHelper = ConstantExpressionHelperFactory.GetInstance(config ?? ParsingConfig.Default);
         }
 
         /// <summary>
@@ -77,38 +79,38 @@ public Expression ParseIntegerLiteral(int tokenPosition, string text)
                 {
                     if (qualifier == "U" || qualifier == "u")
                     {
-                        return ConstantExpressionHelper.CreateLiteral((uint)unsignedValue, text);
+                        return _constantExpressionHelper.CreateLiteral((uint)unsignedValue, text);
                     }
 
                     if (qualifier == "L" || qualifier == "l")
                     {
-                        return ConstantExpressionHelper.CreateLiteral((long)unsignedValue, text);
+                        return _constantExpressionHelper.CreateLiteral((long)unsignedValue, text);
                     }
 
                     if (QualifiersReal.Contains(qualifier))
                     {
                         return ParseRealLiteral(text, qualifier[0], false);
                     }
 
-                    return ConstantExpressionHelper.CreateLiteral(unsignedValue, text);
+                    return _constantExpressionHelper.CreateLiteral(unsignedValue, text);
                 }
 
                 if (unsignedValue <= int.MaxValue)
                 {
-                    return ConstantExpressionHelper.CreateLiteral((int)unsignedValue, text);
+                    return _constantExpressionHelper.CreateLiteral((int)unsignedValue, text);
                 }
 
                 if (unsignedValue <= uint.MaxValue)
                 {
-                    return ConstantExpressionHelper.CreateLiteral((uint)unsignedValue, text);
+                    return _constantExpressionHelper.CreateLiteral((uint)unsignedValue, text);
                 }
 
                 if (unsignedValue <= long.MaxValue)
                 {
-                    return ConstantExpressionHelper.CreateLiteral((long)unsignedValue, text);
+                    return _constantExpressionHelper.CreateLiteral((long)unsignedValue, text);
                 }
 
-                return ConstantExpressionHelper.CreateLiteral(unsignedValue, text);
+                return _constantExpressionHelper.CreateLiteral(unsignedValue, text);
             }
 
             if (isHexadecimal || isBinary)
@@ -135,7 +137,7 @@ public Expression ParseIntegerLiteral(int tokenPosition, string text)
             {
                 if (qualifier == "L" || qualifier == "l")
                 {
-                    return ConstantExpressionHelper.CreateLiteral(value, text);
+                    return _constantExpressionHelper.CreateLiteral(value, text);
                 }
 
                 if (QualifiersReal.Contains(qualifier))
@@ -148,10 +150,10 @@ public Expression ParseIntegerLiteral(int tokenPosition, string text)
 
             if (value <= int.MaxValue)
             {
-                return ConstantExpressionHelper.CreateLiteral((int)value, text);
+                return _constantExpressionHelper.CreateLiteral((int)value, text);
             }
 
-            return ConstantExpressionHelper.CreateLiteral(value, text);
+            return _constantExpressionHelper.CreateLiteral(value, text);
         }
 
         /// <summary>
@@ -163,18 +165,18 @@ public Expression ParseRealLiteral(string text, char qualifier, bool stripQualif
             {
                 case 'f':
                 case 'F':
-                    return ConstantExpressionHelper.CreateLiteral(ParseNumber(stripQualifier ? text.Substring(0, text.Length - 1) : text, typeof(float))!, text);
+                    return _constantExpressionHelper.CreateLiteral(ParseNumber(stripQualifier ? text.Substring(0, text.Length - 1) : text, typeof(float))!, text);
 
                 case 'm':
                 case 'M':
-                    return ConstantExpressionHelper.CreateLiteral(ParseNumber(stripQualifier ? text.Substring(0, text.Length - 1) : text, typeof(decimal))!, text);
+                    return _constantExpressionHelper.CreateLiteral(ParseNumber(stripQualifier ? text.Substring(0, text.Length - 1) : text, typeof(decimal))!, text);
 
                 case 'd':
                 case 'D':
-                    return ConstantExpressionHelper.CreateLiteral(ParseNumber(stripQualifier ? text.Substring(0, text.Length - 1) : text, typeof(double))!, text);
+                    return _constantExpressionHelper.CreateLiteral(ParseNumber(stripQualifier ? text.Substring(0, text.Length - 1) : text, typeof(double))!, text);
 
                 default:
-                    return ConstantExpressionHelper.CreateLiteral(ParseNumber(text, typeof(double))!, text);
+                    return _constantExpressionHelper.CreateLiteral(ParseNumber(text, typeof(double))!, text);
             }
         }
 
@@ -285,12 +287,12 @@ private Expression ParseAsBinary(int tokenPosition, string text, bool isNegative
         {
             if (RegexBinary32.IsMatch(text))
             {
-                return ConstantExpressionHelper.CreateLiteral((isNegative ? -1 : 1) * Convert.ToInt32(text, 2), text);
+                return _constantExpressionHelper.CreateLiteral((isNegative ? -1 : 1) * Convert.ToInt32(text, 2), text);
             }
 
             if (RegexBinary64.IsMatch(text))
             {
-                return ConstantExpressionHelper.CreateLiteral((isNegative ? -1 : 1) * Convert.ToInt64(text, 2), text);
+                return _constantExpressionHelper.CreateLiteral((isNegative ? -1 : 1) * Convert.ToInt64(text, 2), text);
             }
 
             throw new ParseException(string.Format(_culture, Res.InvalidBinaryIntegerLiteral, text), tokenPosition);

src/System.Linq.Dynamic.Core/ParsingConfig.cs

@@ -3,6 +3,7 @@
 using System.Globalization;
 using System.Linq.Dynamic.Core.CustomTypeProviders;
 using System.Linq.Dynamic.Core.Parser;
+using System.Linq.Dynamic.Core.Util.Cache;
 
 namespace System.Linq.Dynamic.Core;
 
@@ -234,4 +235,9 @@ public IQueryableAnalyzer QueryableAnalyzer
     /// Default value is <c>false</c>.
     /// </summary>
     public bool DisallowNewKeyword { get; set; } = false;
+
+    /// <summary>
+    /// Caches constant expressions to enhance performance. Periodic cleanup is performed to manage cache size, governed by this configuration.
+    /// </summary>
+    public CacheConfig? ConstantExpressionCacheConfig { get; set; }
 }

src/System.Linq.Dynamic.Core/Util/Cache/CacheConfig.cs

@@ -0,0 +1,27 @@
+namespace System.Linq.Dynamic.Core.Util.Cache;
+
+/// <summary>
+/// Cache Configuration Options
+/// </summary>
+public class CacheConfig
+{
+    /// <summary>
+    /// Sets a Time-To-Live (TTL) for items in the constant expression cache to prevent uncontrolled growth. 
+    /// Items not accessed within this TTL will be expired, allowing garbage collection to reclaim the memory.
+    /// Default is 10 minutes.
+    /// </summary>
+    public TimeSpan TimeToLive { get; set; } = TimeSpan.FromMinutes(10);
+
+    /// <summary>
+    /// Configures the minimum number of items required in the constant expression cache before triggering cleanup. 
+    /// This prevents frequent cleanups, especially in caches with few items. 
+    /// A default value of null implies that cleanup is always allowed to run, helping in timely removal of unused cache items.
+    /// </summary>
+    public int? MinItemsTrigger { get; set; }
+
+    /// <summary>
+    /// Sets the frequency for running the cleanup process in the Constant Expression cache. 
+    /// By default, cleanup occurs every 10 minutes.
+    /// </summary>
+    public TimeSpan CleanupFrequency { get; set; } = TimeSpan.FromMinutes(10);
+}

src/System.Linq.Dynamic.Core/Util/Cache/CacheEntry.cs

@@ -0,0 +1,14 @@
+namespace System.Linq.Dynamic.Core.Util.Cache;
+
+internal struct CacheEntry<TValue> where TValue : notnull
+{
+    public TValue Value { get; }
+
+    public DateTime ExpirationTime { get; }
+
+    public CacheEntry(TValue value, DateTime expirationTime) 
+    {
+        Value = value;
+        ExpirationTime = expirationTime;
+    }
+}