Use pooled arrays during list completion.

src/HotChocolate/Core/src/Types/Execution/Processing/ValueCompletion.List.cs

@@ -1,3 +1,4 @@
+using System.Buffers;
 using System.Collections;
 using System.Text.Json;
 using HotChocolate.Text.Json;
@@ -96,31 +97,51 @@ private static void CompleteListValue(
 
         if (runtimeValue is IEnumerable enumerable)
         {
-            var i = 0;
-            var temp = new List<object?>();
+            var count = 0;
+            var buffer = ArrayPool<object?>.Shared.Rent(64);
 
-            foreach (var value in enumerable)
+            try
             {
-                temp.Add(value);
-            }
+                foreach (var value in enumerable)
+                {
+                    if (count == buffer.Length)
+                    {
+                        var newBuffer = ArrayPool<object?>.Shared.Rent(buffer.Length * 2);
+                        var span = buffer.AsSpan(0, count);
+                        span.CopyTo(newBuffer);
+                        span.Clear();
+                        ArrayPool<object?>.Shared.Return(buffer);
+                        buffer = newBuffer;
+                    }
+
+                    buffer[count++] = value;
+                }
 
-            resultValue.SetArrayValue(temp.Count);
+                resultValue.SetArrayValue(count);
 
-            foreach (var element in resultValue.EnumerateArray())
-            {
-                Complete(
-                    context,
-                    selection,
-                    elementType,
-                    element,
-                    temp[i++]);
+                var i = 0;
 
-                // if we ran into an error that invalidated the result we abort.
-                if (element.IsInvalidated)
+                foreach (var element in resultValue.EnumerateArray())
                 {
-                    return;
+                    Complete(
+                        context,
+                        selection,
+                        elementType,
+                        element,
+                        buffer[i++]);
+
+                    // if we ran into an error that invalidated the result we abort.
+                    if (element.IsInvalidated)
+                    {
+                        return;
+                    }
                 }
             }
+            finally
+            {
+                buffer.AsSpan(0, count).Clear();
+                ArrayPool<object?>.Shared.Return(buffer);
+            }
 
             return;
         }