refactor: Refactor score processing and service utilities

- Improved StdDevScoreProcesser to utilize parallel processing and simplified logic for ranking records.
- Enhanced StealScoreProcesser with a FrozenDictionary for control records and optimized record selection.
- Updated BestsService and DfBestsService to use Task.WhenAll for asynchronous data preparation.
- Refactored DfListService and ListService to streamline record conversion and data retrieval.
- Introduced FrozenSet and FrozenDictionary in various services for improved performance and memory efficiency.
- Simplified score filtering logic in ScoreFilterHelper and ScoreProcesserHelper.
- Added new rating factors and utility methods in ConstantMap for better rank resolution.
- Enhanced Union class with caching for JSON property names to optimize serialization performance.

Author: Yushu2606

src/Prober/DivingFish/Models/Status.cs

@@ -1,3 +1,5 @@
+using System.Collections.Frozen;
+using System.Collections.Immutable;
 using System.Text.Json.Serialization;
 
 namespace Limekuma.Prober.DivingFish.Models;
@@ -12,6 +14,27 @@ public record Status
     [JsonPropertyName("diff_data")]
     public required Dictionary<string, LevelState> LevelStatus { get; init; }
 
+    public FrozenDictionary<string, ImmutableArray<ChartState>> FrozenChartStatus => field ??= ChartStatus.ToFrozenDictionary(pair => pair.Key, pair => pair.Value.ToImmutableArray(), StringComparer.Ordinal);
+
+    public FrozenDictionary<string, LevelState> FrozenLevelStatus => field ??= LevelStatus.ToFrozenDictionary(StringComparer.Ordinal);
+
+    public bool TryGetChartState(int songId, int difficultyIndex, out ChartState chartState)
+    {
+        chartState = null!;
+        if (!FrozenChartStatus.TryGetValue(songId.ToString(), out ImmutableArray<ChartState> chartStates))
+        {
+            return false;
+        }
+
+        if (difficultyIndex >= chartStates.Length)
+        {
+            return false;
+        }
+
+        chartState = chartStates[difficultyIndex];
+        return true;
+    }
+
     public static Status Shared
     {
         get

src/Prober/Lxns/LxnsResourceClient.cs

@@ -9,15 +9,15 @@ private async Task<T> GetListAsync<T>(string type, string includeType, int? vers
         CancellationToken cancellationToken = default)
     {
         string url = $"/api/v0/maimai/{type}/list";
-        List<string> queryParams = [];
+        List<string> queryParts = [];
         if (version.HasValue)
         {
-            queryParams.Add($"version={version}");
+            queryParts.Add($"version={version.Value}");
         }
 
         if (include.HasValue)
         {
-            queryParams.Add($"{includeType}={include.Value.ToString().ToLower()}");
+            queryParts.Add($"{includeType}={include.Value.ToString().ToLowerInvariant()}");
         }
 
         if (queryParams.Count > 0)

src/Prober/Lxns/Models/Player.cs

@@ -6,6 +6,7 @@ namespace Limekuma.Prober.Lxns.Models;
 
 public record Player
 {
+    [JsonIgnore]
     public LxnsDeveloperClient? Client { get; internal set; }
 
     [JsonPropertyName("name")]

src/Render/AssetProvider.cs

@@ -2,6 +2,8 @@
 using SixLabors.ImageSharp;
 using SmartFormat;
 using System.Collections.Concurrent;
+using System.Collections.Frozen;
+using System.Collections.Immutable;
 using System.Xml.Linq;
 
 namespace Limekuma.Render;
@@ -10,8 +12,9 @@ public sealed class AssetProvider
 {
     private readonly ConcurrentDictionary<string, Image> _assets;
     private readonly ConcurrentDictionary<string, LoadedFont> _fontCache;
-    private readonly Dictionary<string, (string, List<string>?)> _fontRules;
-    private readonly Dictionary<string, (string, string?)> _pathRules;
+    private readonly ConcurrentDictionary<string, ImmutableArray<FontFamily>> _fontFallbackCache;
+    private readonly FrozenDictionary<string, (string, ImmutableArray<string>)> _fontRules;
+    private readonly FrozenDictionary<string, (string, string?)> _pathRules;
 
     static AssetProvider() => Shared = new();
 
@@ -21,11 +24,10 @@ public AssetProvider() : this("./Resources/Resources.xml")
 
     public AssetProvider(string resourcePath)
     {
-        _fontRules = [];
-        _pathRules = [];
         _assets = [];
         _fontCache = [];
-        LoadResources(resourcePath);
+        _fontFallbackCache = [];
+        (_pathRules, _fontRules) = LoadResources(resourcePath);
     }
 
     public static AssetProvider Shared { get; }
@@ -36,21 +38,21 @@ public Image LoadImage(string ns, string key)
         return LoadImage(path);
     }
 
-    public (FontFamily, List<FontFamily>) ResolveFont(string key)
+    public (FontFamily, ImmutableArray<FontFamily>) ResolveFont(string key)
     {
-        if (!_fontRules.TryGetValue(key, out (string, List<string>?) font))
+        if (!_fontRules.TryGetValue(key, out (string, ImmutableArray<string>) font))
         {
             throw new FontFamilyNotFoundException(key);
         }
 
-        (string mainFontName, List<string>? fallbackNames) = font;
+        (string mainFontName, ImmutableArray<string> fallbackNames) = font;
         FontFamily mainFont = LoadFont(mainFontName);
-        if (fallbackNames is null)
+        if (fallbackNames.IsDefaultOrEmpty)
         {
             return (mainFont, []);
         }
 
-        List<FontFamily> fallbacks = [.. fallbackNames.Select(LoadFont)];
+        ImmutableArray<FontFamily> fallbacks = _fontFallbackCache.GetOrAdd(key, _ => [.. fallbackNames.Select(LoadFont)]);
         return (mainFont, fallbacks);
     }
 
@@ -65,67 +67,36 @@ public Image LoadImage(string ns, string key)
         return path;
     }
 
-    private void LoadResources(string resourcePath)
+    private static (FrozenDictionary<string, (string, string?)>, FrozenDictionary<string, (string, ImmutableArray<string>)>) LoadResources(string resourcePath)
     {
         XDocument doc = XDocument.Load(resourcePath);
         XElement? resources = doc.Element("Resources");
         if (resources is null)
         {
-            return;
+            return (FrozenDictionary<string, (string, string?)>.Empty, FrozenDictionary<string, (string, ImmutableArray<string>)>.Empty);
         }
 
-        LoadPathRules(resources);
-        LoadFontRules(resources);
+        return (LoadPathRules(resources), LoadFontRules(resources));
     }
 
-    private void LoadPathRules(XElement resourcesNode)
+    private static FrozenDictionary<string, (string, string?)> LoadPathRules(XElement resourcesNode) => resourcesNode.Elements("Path").Select(node => new
     {
-        foreach (XElement node in resourcesNode.Elements("Path"))
-        {
-            string? ns = node.Attribute("namespace")?.Value;
-            string path = node.Value;
-            if (string.IsNullOrEmpty(ns))
-            {
-                continue;
-            }
-
-            if (string.IsNullOrEmpty(path))
-            {
-                continue;
-            }
-
-            _pathRules[ns] = new(path, node.Attribute("rule")?.Value);
-        }
-    }
-
-    private void LoadFontRules(XElement resourcesNode)
-    {
-        foreach (XElement node in resourcesNode.Elements("FontFamily"))
-        {
-            string? ns = node.Attribute("namespace")?.Value;
-            string? fontPath = node.Element("Font")?.Value;
-            if (string.IsNullOrEmpty(ns))
-            {
-                continue;
-            }
-
-            if (string.IsNullOrEmpty(fontPath))
-            {
-                continue;
-            }
+        Namespace = node.Attribute("namespace")?.Value,
+        Path = node.Value,
+        Rule = node.Attribute("rule")?.Value
+    }).Where(x => !string.IsNullOrEmpty(x.Namespace) && !string.IsNullOrEmpty(x.Path)).ToFrozenDictionary(x => x.Namespace!, x => (x.Path, x.Rule));
 
-            XElement? fallbacks = node.Element("Fallbacks");
-            if (fallbacks is null)
+    private static FrozenDictionary<string, (string, ImmutableArray<string>)> LoadFontRules(XElement resourcesNode) => resourcesNode.Elements("FontFamily").Select(node =>
             {
-                _fontRules[ns] = new(fontPath, null);
-                continue;
-            }
-
-            List<string> fallbackPaths =
-                [.. fallbacks.Elements("Font").Select(e => e.Value).Where(p => !string.IsNullOrEmpty(p))];
-            _fontRules[ns] = new(fontPath, fallbackPaths);
-        }
-    }
+                string? fontPath = node.Element("Font")?.Value;
+                ImmutableArray<string> fallbackPaths = [.. node.Element("Fallbacks")?.Elements("Font").Select(e => e.Value).Where(p => !string.IsNullOrEmpty(p)) ?? []];
+                return new
+                {
+                    Namespace = node.Attribute("namespace")?.Value,
+                    FontPath = fontPath,
+                    Fallbacks = fallbackPaths
+                };
+            }).Where(x => !string.IsNullOrEmpty(x.Namespace) && !string.IsNullOrEmpty(x.FontPath)).ToFrozenDictionary(x => x.Namespace!, x => (x.FontPath!, x.Fallbacks));
 
     private string ResolveResourcePath(string ns, string key)
     {

src/Render/Drawer.cs

@@ -9,6 +9,8 @@ namespace Limekuma.Render;
 
 public sealed class Drawer
 {
+    private static readonly AsyncNCalcEngine ExpressionEngine = CreateExpressionEngine();
+
     public async Task<Image> DrawBestsAsync(CommonUser user, IReadOnlyList<CommonRecord> ever,
         IReadOnlyList<CommonRecord> current, int everTotal, int currentTotal, string? condition, string prober,
         IEnumerable<string> tags) => await DrawBestsAsync(user, ever, current, everTotal, currentTotal, condition,
@@ -79,17 +81,17 @@ public async Task<Image> DrawListAsync(CommonUser user, IReadOnlyList<CommonReco
 
     private static async Task<Image> DrawAsync(IDictionary<string, object?> scope, string xmlPath)
     {
-        AsyncNCalcEngine expr = new();
-        RegisterFunctions(expr);
-        TemplateReader loader = new(expr);
+        TemplateReader loader = new(ExpressionEngine);
         Node tree = await loader.LoadAsync(xmlPath, scope);
         AssetProvider assets = AssetProvider.Shared;
         return NodeRenderer.Render((CanvasNode)tree, assets, assets);
     }
 
-    private static void RegisterFunctions(AsyncNCalcEngine expr)
+    private static AsyncNCalcEngine CreateExpressionEngine()
     {
+        AsyncNCalcEngine expr = new();
         expr.RegisterFunction("ToString", (object x) => Convert.ToString(x));
         expr.RegisterFunction("Count", (IList x) => x.Count);
+        return expr;
     }
 }

src/Render/ExpressionEngine/AsyncNCalcEngine.cs

@@ -9,8 +9,13 @@ namespace Limekuma.Render.ExpressionEngine;
 public sealed class AsyncNCalcEngine
 {
     private readonly ConcurrentDictionary<string, Delegate> _functions = new();
+    private readonly ConcurrentDictionary<string, ParameterInfo[]> _functionParameters = new();
 
-    public void RegisterFunction(string name, Delegate func) => _functions[name] = func;
+    public void RegisterFunction(string name, Delegate func)
+    {
+        _functions[name] = func;
+        _functionParameters[name] = func.Method.GetParameters();
+    }
 
     public async Task<T?> EvalAsync<T>(string expr, object? scope)
     {
@@ -35,20 +40,14 @@ public sealed class AsyncNCalcEngine
             return (T?)ConvertValue(result, typeof(T));
         }
 
-        List<object> list = [];
-        list.AddRange(enumerable.OfType<object>());
-
-        return (T)(object)list;
+        return (T)(object)enumerable.Cast<object?>().Where(item => item is not null).Cast<object>().ToArray();
     }
 
     public async Task<object?> EvalAsync(string expr, object? scope)
     {
         AsyncExpression expression = new(expr);
         Dictionary<string, object?> flattened = ScopeFlattener.Flatten(scope);
-        foreach ((string key, object? value) in flattened)
-        {
-            expression.Parameters[key] = value is Enum e ? Convert.ToInt32(e, CultureInfo.InvariantCulture) : value;
-        }
+        AddScopeParameters(expression, flattened);
 
         expression.EvaluateFunctionAsync += async (name, args) =>
         {
@@ -57,7 +56,7 @@ public sealed class AsyncNCalcEngine
                 return;
             }
 
-            ParameterInfo[] parameters = func.Method.GetParameters();
+            ParameterInfo[] parameters = _functionParameters.GetOrAdd(name, _ => func.Method.GetParameters());
             object?[] funcArgs = new object[args.Parameters.Length];
             for (int i = 0; i < args.Parameters.Length; ++i)
             {
@@ -73,6 +72,14 @@ public sealed class AsyncNCalcEngine
         return await expression.EvaluateAsync();
     }
 
+    private static void AddScopeParameters(AsyncExpression expression, Dictionary<string, object?> flattened)
+    {
+        foreach ((string key, object? value) in flattened)
+        {
+            expression.Parameters[key] = value is Enum e ? Convert.ToInt32(e, CultureInfo.InvariantCulture) : value;
+        }
+    }
+
     private static object? ConvertValue(object? value, Type targetType)
     {
         if (value is null)

src/Render/ExpressionEngine/ScopeFlattener.cs

@@ -1,11 +1,16 @@
 using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Immutable;
 using System.Globalization;
 using System.Reflection;
 
 namespace Limekuma.Render.ExpressionEngine;
 
 internal static class ScopeFlattener
 {
+    private static readonly ConcurrentDictionary<Type, ImmutableArray<PropertyInfo>> PropertyCache = new();
+    private static readonly ConcurrentDictionary<Type, bool> LeafTypeCache = new();
+
     public static Dictionary<string, object?> Flatten(object? scope)
     {
         Dictionary<string, object?> result = new(StringComparer.OrdinalIgnoreCase);
@@ -41,13 +46,19 @@ private static void FlattenObject(IDictionary<string, object?> output, string pr
         }
 
         Type type = value.GetType();
-        if (type.IsPrimitive)
+        if (IsLeafType(type))
         {
             return;
         }
 
-        if (value is string or decimal or DateTime or DateTimeOffset or TimeSpan or Guid or Enum)
+        if (value is IDictionary<string, object?> genericDictionary)
         {
+            foreach ((string key, object? entryValue) in genericDictionary)
+            {
+                string childPrefix = prefix.Length is 0 ? key : string.Concat(prefix, ".", key);
+                FlattenObject(output, childPrefix, entryValue, depth + 1);
+            }
+
             return;
         }
 
@@ -56,7 +67,7 @@ private static void FlattenObject(IDictionary<string, object?> output, string pr
             foreach (DictionaryEntry entry in dictionary)
             {
                 string key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture) ?? string.Empty;
-                string childPrefix = string.IsNullOrEmpty(prefix) ? key : $"{prefix}.{key}";
+                string childPrefix = prefix.Length is 0 ? key : string.Concat(prefix, ".", key);
                 FlattenObject(output, childPrefix, entry.Value, depth + 1);
             }
 
@@ -68,22 +79,14 @@ private static void FlattenObject(IDictionary<string, object?> output, string pr
             return;
         }
 
-        PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
+        ImmutableArray<PropertyInfo> properties = PropertyCache.GetOrAdd(type, static t => [.. t.GetProperties(BindingFlags.Instance | BindingFlags.Public).Where(property => property.CanRead && property.GetIndexParameters().Length is 0)]);
         foreach (PropertyInfo property in properties)
         {
-            if (!property.CanRead)
-            {
-                continue;
-            }
-
-            if (property.GetIndexParameters().Length > 0)
-            {
-                continue;
-            }
-
             object? propertyValue = property.GetValue(value);
-            string childName = string.IsNullOrEmpty(prefix) ? property.Name : $"{prefix}.{property.Name}";
+            string childName = prefix.Length is 0 ? property.Name : string.Concat(prefix, ".", property.Name);
             FlattenObject(output, childName, propertyValue, depth + 1);
         }
     }
+
+    private static bool IsLeafType(Type type) => LeafTypeCache.GetOrAdd(type, static t => t.IsPrimitive || t.IsEnum || t == typeof(string) || t == typeof(decimal) || t == typeof(DateTime) || t == typeof(DateTimeOffset) || t == typeof(TimeSpan) || t == typeof(Guid));
 }