refactor: Optimize code with more generic collection types and LINQ

- Changed the `Children` property of multiple node classes from `List<Node>` to `IEnumerable<Node>` for improved flexibility
- Refactored multiple algorithms using LINQ queries and immutable collections to simplify code logic
- Optimized parallel queries to avoid unnecessary `ToArray()` calls
- Refactored conditional branches and loop processing to improve readability and performance

Author: Yushu2606

src/Prober/Lxns/LxnsResourceClient.cs

@@ -9,20 +9,14 @@ private async Task<T> GetListAsync<T>(string type, string includeType, int? vers
         CancellationToken cancellationToken = default)
     {
         string url = $"/api/v0/maimai/{type}/list";
-        List<string> queryParts = [];
-        if (version.HasValue)
-        {
-            queryParts.Add($"version={version.Value}");
-        }
-
-        if (include.HasValue)
+        string query = string.Join("&", new[]
         {
-            queryParts.Add($"{includeType}={include.Value.ToString().ToLowerInvariant()}");
-        }
-
-        if (queryParts.Count > 0)
+            version.HasValue ? $"version={version.Value}" : null,
+            include.HasValue ? $"{includeType}={include.Value.ToString().ToLowerInvariant()}" : null
+        }.OfType<string>());
+        if (!string.IsNullOrWhiteSpace(query))
         {
-            url += $"?{string.Join("&", queryParts)}";
+            url += $"?{query}";
         }
 
         T response = await GetAsync<T>(url, cancellationToken);

src/Render/ExpressionEngine/AsyncNCalcEngine.cs

@@ -40,7 +40,7 @@ public void RegisterFunction(string name, Delegate func)
             return (T?)ConvertValue(result, typeof(T));
         }
 
-        return (T)(object)enumerable.Cast<object?>().Where(item => item is not null).Cast<object>().ToArray();
+        return (T)enumerable.OfType<object>();
     }
 
     public async Task<object?> EvalAsync(string expr, object? scope)
@@ -57,15 +57,12 @@ public void RegisterFunction(string name, Delegate func)
             }
 
             ParameterInfo[] parameters = _functionParameters.GetOrAdd(name, _ => func.Method.GetParameters());
-            object?[] funcArgs = new object[args.Parameters.Length];
-            for (int i = 0; i < args.Parameters.Length; ++i)
-            {
-                object? paramValue = await args.Parameters[i].EvaluateAsync();
-                funcArgs[i] = CoerceValue(paramValue,
-                    i < parameters.Length ? parameters[i].ParameterType : typeof(object));
-            }
+            object?[] evaluatedArgs =
+                await Task.WhenAll(args.Parameters.Select(parameter => parameter.EvaluateAsync().AsTask()));
+            IEnumerable<object?> funcArgs = evaluatedArgs.Select((paramValue, index) =>
+                CoerceValue(paramValue, index < parameters.Length ? parameters[index].ParameterType : typeof(object)));
 
-            object? result = func.DynamicInvoke(funcArgs);
+            object? result = func.DynamicInvoke([.. funcArgs]);
             args.Result = result;
         };
 

src/Render/NodeRenderer.Layout.cs

@@ -1,6 +1,7 @@
 using Limekuma.Render.Nodes;
 using Limekuma.Render.Types;
 using SixLabors.ImageSharp;
+using System.Collections.Immutable;
 
 namespace Limekuma.Render;
 
@@ -9,11 +10,14 @@ public static partial class NodeRenderer
     private static float ResolveMainAxisContainerSize(int? explicitSize, int? desiredSize, float fallback) =>
         explicitSize ?? desiredSize ?? fallback;
 
-    private static List<List<(Node Node, Size Size)>> ResolveStackLines(IEnumerable<(Node Node, Size Size)> items,
+    private static ImmutableArray<ImmutableArray<(Node Node, Size Size)>> ResolveStackLines(
+        IEnumerable<(Node Node, Size Size)> items,
         bool isRow, bool wrap, float spacing, float containerMain)
     {
-        List<List<(Node Node, Size Size)>> lines = [];
-        List<(Node Node, Size Size)> currentLine = [];
+        ImmutableArray<ImmutableArray<(Node Node, Size Size)>>.Builder lines =
+            ImmutableArray.CreateBuilder<ImmutableArray<(Node Node, Size Size)>>();
+        ImmutableArray<(Node Node, Size Size)>.Builder currentLine =
+            ImmutableArray.CreateBuilder<(Node Node, Size Size)>();
         float currentMain = 0;
         foreach ((Node node, Size size) in items)
         {
@@ -22,8 +26,8 @@ private static float ResolveMainAxisContainerSize(int? explicitSize, int? desire
             bool wrapNow = wrap && currentLine.Count > 0 && nextMain > containerMain;
             if (wrapNow)
             {
-                lines.Add(currentLine);
-                currentLine = [];
+                lines.Add(currentLine.ToImmutable());
+                currentLine = ImmutableArray.CreateBuilder<(Node Node, Size Size)>();
                 currentMain = 0;
             }
 
@@ -33,32 +37,25 @@ private static float ResolveMainAxisContainerSize(int? explicitSize, int? desire
 
         if (currentLine.Count > 0)
         {
-            lines.Add(currentLine);
+            lines.Add(currentLine.ToImmutable());
         }
 
-        return lines;
+        return lines.ToImmutable();
     }
 
-    private static List<(float Main, int Cross)> ResolveStackLineSizes(
-        IEnumerable<IReadOnlyList<(Node Node, Size Size)>> lines, bool isRow, float spacing)
-    {
-        List<(float Main, int Cross)> lineSizes = [];
-        foreach (IReadOnlyList<(Node Node, Size Size)> line in lines)
+    private static ImmutableArray<(float Main, int Cross)> ResolveStackLineSizes(
+        IEnumerable<IReadOnlyList<(Node Node, Size Size)>> lines, bool isRow, float spacing) =>
+    [
+        .. lines.Select(line =>
         {
-            float lineMain = line.Sum(i => isRow ? i.Size.Width : i.Size.Height);
-            if (line.Count > 1)
-            {
-                lineMain += spacing * (line.Count - 1);
-            }
-
+            float lineMain = line.Sum(i => isRow ? i.Size.Width : i.Size.Height) +
+                             (line.Count > 1 ? spacing * (line.Count - 1) : 0);
             int lineCross = line.Max(i => isRow ? i.Size.Height : i.Size.Width);
-            lineSizes.Add((lineMain, lineCross));
-        }
-
-        return lineSizes;
-    }
+            return (lineMain, lineCross);
+        })
+    ];
 
-    private static (float Main, float Cross) ResolveStackContentSize(List<(float Main, int Cross)> lineSizes,
+    private static (float Main, float Cross) ResolveStackContentSize(IReadOnlyList<(float Main, int Cross)> lineSizes,
         float runSpacing)
     {
         if (lineSizes.Count is 0)

src/Render/NodeRenderer.Measurement.cs

@@ -79,21 +79,21 @@ private static Size MeasureResizedNode(ResizedNode resized, AssetProvider assets
     private static Size MeasureStackNode(StackNode stack, AssetProvider assets, AssetProvider measurer,
         ConcurrentDictionary<Node, Size> measurementCache)
     {
-        List<Node> flowChildren = ExpandFlowChildren(stack.Children);
+        IReadOnlyList<Node> flowChildren = [.. ExpandFlowChildren(stack.Children)];
         List<(Node Node, Size Size)> items = [];
         if (flowChildren.Count > 0)
         {
             Size[] sizes = new Size[flowChildren.Count];
             Parallel.For(0, flowChildren.Count,
                 i => { sizes[i] = Measure(flowChildren[i], assets, measurer, measurementCache); });
-            items.EnsureCapacity(flowChildren.Count);
-            items.AddRange(flowChildren.Select((t, i) => (t, sizes[i])));
+            items = [.. flowChildren.Select((child, index) => (child, sizes[index]))];
         }
 
         bool isRow = stack.Direction is StackDirection.Row;
         float wrapMain = ResolveMainAxisContainerSize(isRow ? stack.Width : stack.Height, null, int.MaxValue);
-        List<List<(Node Node, Size Size)>> lines = ResolveStackLines(items, isRow, stack.Wrap, stack.Spacing, wrapMain);
-        List<(float Main, int Cross)> lineSizes = ResolveStackLineSizes(lines, isRow, stack.Spacing);
+        ImmutableArray<ImmutableArray<(Node Node, Size Size)>> lines =
+            ResolveStackLines(items, isRow, stack.Wrap, stack.Spacing, wrapMain);
+        ImmutableArray<(float Main, int Cross)> lineSizes = ResolveStackLineSizes([.. lines], isRow, stack.Spacing);
         (float contentMain, float contentCross) = ResolveStackContentSize(lineSizes, stack.RunSpacing);
 
         int contentWidth = (int)Math.Ceiling(isRow ? contentMain : contentCross);
@@ -104,7 +104,7 @@ private static Size MeasureStackNode(StackNode stack, AssetProvider assets, Asse
     private static Size MeasureGridNode(GridNode grid, AssetProvider assets, AssetProvider measurer,
         ConcurrentDictionary<Node, Size> measurementCache)
     {
-        List<Node> flowChildren = ExpandFlowChildren(grid.Children);
+        IReadOnlyList<Node> flowChildren = [.. ExpandFlowChildren(grid.Children)];
         if (flowChildren.Count is 0)
         {
             return Size.Empty;
@@ -115,16 +115,10 @@ private static Size MeasureGridNode(GridNode grid, AssetProvider assets, AssetPr
         Size[] sizes = new Size[flowChildren.Count];
         Parallel.For(0, flowChildren.Count,
             i => { sizes[i] = Measure(flowChildren[i], assets, measurer, measurementCache); });
-        int[] colWidths = new int[columns];
-        int[] rowHeights = new int[rows];
-        for (int i = 0; i < flowChildren.Count; i++)
-        {
-            Size size = sizes[i];
-            int r = i / columns;
-            int c = i % columns;
-            colWidths[c] = Math.Max(colWidths[c], size.Width);
-            rowHeights[r] = Math.Max(rowHeights[r], size.Height);
-        }
+        IEnumerable<int> colWidths = Enumerable.Range(0, columns).Select(c =>
+            sizes.Where((_, i) => i % columns == c).DefaultIfEmpty(Size.Empty).Max(size => size.Width));
+        IEnumerable<int> rowHeights = Enumerable.Range(0, rows).Select(r =>
+            sizes.Where((_, i) => i / columns == r).DefaultIfEmpty(Size.Empty).Max(size => size.Height));
 
         int width = colWidths.Sum() + (Math.Max(0, columns - 1) * grid.ColumnGap);
         int height = rowHeights.Sum() + (Math.Max(0, rows - 1) * grid.RowGap);
@@ -147,32 +141,14 @@ private static Size MeasureLayerNode(LayerNode layer, AssetProvider assets, Asse
     private static Size MeasureChildren(IEnumerable<Node> children, AssetProvider assets, AssetProvider measurer,
         ConcurrentDictionary<Node, Size> measurementCache)
     {
-        int width = 0;
-        int height = 0;
-        foreach (Node child in children)
-        {
-            Size size = Measure(child, assets, measurer, measurementCache);
-            width = Math.Max(width, size.Width);
-            height = Math.Max(height, size.Height);
-        }
-
+        (int width, int height) = children.Select(child => Measure(child, assets, measurer, measurementCache))
+            .Aggregate((Width: 0, Height: 0),
+                static (acc, size) => (Math.Max(acc.Width, size.Width), Math.Max(acc.Height, size.Height)));
         return new(width, height);
     }
 
-    private static List<Node> ExpandFlowChildren(IEnumerable<Node> children)
-    {
-        List<Node> output = [];
-        foreach (Node child in children)
-        {
-            if (child is LayerNode { Opacity: 1, Key: null, Children: var nested })
-            {
-                output.AddRange(ExpandFlowChildren(nested));
-                continue;
-            }
-
-            output.Add(child);
-        }
-
-        return output;
-    }
+    private static IEnumerable<Node> ExpandFlowChildren(IEnumerable<Node> children) =>
+        children.SelectMany(static child => child is LayerNode { Opacity: 1, Key: null, Children: var nested }
+            ? ExpandFlowChildren(nested)
+            : [child]);
 }

src/Render/NodeRenderer.Rendering.cs

@@ -79,7 +79,7 @@ private static void RenderStackNode(Image canvas, StackNode stack, AssetProvider
         Point origin, float inheritedOpacity, Size? desiredSize, float scale, ResamplerType resampler,
         ConcurrentDictionary<Node, Size> measurementCache)
     {
-        List<Node> flowChildren = ExpandFlowChildren(stack.Children);
+        IReadOnlyList<Node> flowChildren = [.. ExpandFlowChildren(stack.Children)];
         List<(Node Node, Size Size)> items = [];
         if (flowChildren.Count > 0)
         {
@@ -97,8 +97,9 @@ private static void RenderStackNode(Image canvas, StackNode stack, AssetProvider
 
         bool isRow = stack.Direction is StackDirection.Row;
         float wrapMain = ResolveMainAxisContainerSize(isRow ? stack.Width : stack.Height, null, int.MaxValue);
-        List<List<(Node Node, Size Size)>> lines = ResolveStackLines(items, isRow, stack.Wrap, stack.Spacing, wrapMain);
-        List<(float Main, int Cross)> lineSizes = ResolveStackLineSizes(lines, isRow, stack.Spacing);
+        ImmutableArray<ImmutableArray<(Node Node, Size Size)>> lines =
+            ResolveStackLines(items, isRow, stack.Wrap, stack.Spacing, wrapMain);
+        ImmutableArray<(float Main, int Cross)> lineSizes = ResolveStackLineSizes([.. lines], isRow, stack.Spacing);
         (float contentMain, float contentCross) = ResolveStackContentSize(lineSizes, stack.RunSpacing);
         float resolvedContainerMain = ResolveMainAxisContainerSize(isRow ? stack.Width : stack.Height,
             isRow ? desiredSize?.Width : desiredSize?.Height, contentMain);
@@ -113,18 +114,18 @@ private static void RenderStackNode(Image canvas, StackNode stack, AssetProvider
             ? (int)Math.Floor(stack.RunSpacing)
             : (int)Math.Ceiling(stack.RunSpacing);
         float runSpacingFraction = stack.RunSpacing - runSpacingWhole;
-        for (int lineIndex = 0; lineIndex < lines.Count; lineIndex++)
+        for (int lineIndex = 0; lineIndex < lines.Length; lineIndex++)
         {
-            List<(Node Node, Size Size)> line = lines[lineIndex];
+            ImmutableArray<(Node Node, Size Size)> line = lines[lineIndex];
             (float lineMain, int lineCross) = lineSizes[lineIndex];
             (float startMain, float between) = ResolveMainAxisLayout(stack.JustifyContent, resolvedContainerMain,
-                lineMain, stack.Spacing, line.Count);
+                lineMain, stack.Spacing, line.Length);
             float mainBase = (isRow ? origin.X : origin.Y) + startMain;
             int mainCursor = (int)Math.Round(mainBase, MidpointRounding.AwayFromZero);
             float gapError = mainBase - mainCursor;
             int betweenWhole = between >= 0 ? (int)Math.Floor(between) : (int)Math.Ceiling(between);
             float betweenFraction = between - betweenWhole;
-            for (int itemIndex = 0; itemIndex < line.Count; itemIndex++)
+            for (int itemIndex = 0; itemIndex < line.Length; itemIndex++)
             {
                 (Node node, Size size) = line[itemIndex];
                 int itemCross = isRow ? size.Height : size.Width;
@@ -141,7 +142,7 @@ private static void RenderStackNode(Image canvas, StackNode stack, AssetProvider
                     (int)Math.Round(childY, MidpointRounding.AwayFromZero));
                 RenderNode(canvas, node, assets, measurer, childOrigin, inheritedOpacity, childDesiredSize, scale,
                     resampler, measurementCache);
-                if (itemIndex == line.Count - 1)
+                if (itemIndex == line.Length - 1)
                 {
                     continue;
                 }
@@ -163,7 +164,7 @@ private static void RenderStackNode(Image canvas, StackNode stack, AssetProvider
                 mainCursor += step;
             }
 
-            if (lineIndex == lines.Count - 1)
+            if (lineIndex == lines.Length - 1)
             {
                 continue;
             }
@@ -189,7 +190,7 @@ private static void RenderGridNode(Image canvas, GridNode grid, AssetProvider as
         Point origin, float inheritedOpacity, Size? desiredSize, float scale, ResamplerType resampler,
         ConcurrentDictionary<Node, Size> measurementCache)
     {
-        List<Node> flowChildren = ExpandFlowChildren(grid.Children);
+        IReadOnlyList<Node> flowChildren = [.. ExpandFlowChildren(grid.Children)];
         if (flowChildren.Count is 0)
         {
             return;

src/Render/Nodes/CanvasNode.cs

@@ -6,6 +6,6 @@ public sealed record CanvasNode(
     int Width,
     int Height,
     Color? Background,
-    List<Node> Children,
+    IEnumerable<Node> Children,
     string? Key
 ) : Node(Key);

src/Render/Nodes/GridNode.cs

@@ -12,6 +12,6 @@ public sealed record GridNode(
     AlignItems AlignItems,
     int? Width,
     int? Height,
-    List<Node> Children,
+    IEnumerable<Node> Children,
     string? Key
 ) : Node(Key);

src/Render/Nodes/LayerNode.cs

@@ -2,6 +2,6 @@ namespace Limekuma.Render.Nodes;
 
 public sealed record LayerNode(
     float Opacity,
-    List<Node> Children,
+    IEnumerable<Node> Children,
     string? Key
 ) : Node(Key);

src/Render/Nodes/PositionedNode.cs

@@ -9,6 +9,6 @@ public sealed record PositionedNode(
     PositionAnchor AnchorY,
     int? Width,
     int? Height,
-    List<Node> Children,
+    IEnumerable<Node> Children,
     string? Key
 ) : Node(Key);

src/Render/Nodes/StackNode.cs

@@ -12,6 +12,6 @@ public sealed record StackNode(
     ContentAlign AlignContent,
     int? Width,
     int? Height,
-    List<Node> Children,
+    IEnumerable<Node> Children,
     string? Key
 ) : Node(Key);