perf: reuse StringBuilder and ResizeArray in CSV parser to reduce per-field allocations

The readLine inner function previously built a reversed linked list of
field strings using cons (::), then called List.rev |> Array.ofList to
finalise each row. It also allocated a fresh StringBuilder for every
field separator encountered.

This commit replaces that with:
- A single shared StringBuilder (sb) captured in a closure, cleared
  between fields instead of being re-created. This eliminates O(fields *
  rows) StringBuilder allocations for large CSV files.
- A ResizeArray<string> accumulator per row, filled in forward order.
  This replaces the reversed list + two-pass reversal with a single
  O(n) ResizeArray.ToArray() call per row.

The readString helper is updated to append directly to the shared sb
rather than receiving/returning a builder argument.

All 2896 tests pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: github-actions[bot]

RELEASE_NOTES.md

@@ -1,5 +1,9 @@
 # Release Notes
 
+## 8.1.5 - Apr 4 2026
+
+- Performance: CSV parser now reuses a single `StringBuilder` and `ResizeArray` across all fields in a file, eliminating per-field allocations and the list-reversal step; reduces GC pressure when parsing large CSV files with many columns
+
 ## 8.1.4 - Mar 30 2026
 
 - Performance: `JsonValue.Parse` now copies unescaped string runs in bulk instead of appending character-by-character, reducing `StringBuilder.Append` calls for strings with few or no escape sequences

src/FSharp.Data.Csv.Core/CsvRuntime.fs

@@ -36,31 +36,44 @@ module internal CsvReader =
             else
                 None
 
+        // Shared buffer reused across all fields in the entire file to reduce GC allocation.
+        let sb = StringBuilder()
+
         /// Read quoted string value until the end (ends with end of stream or
-        /// the " character, which can be encoded using double ")
-        let rec readString (chars: StringBuilder) =
+        /// the " character, which can be encoded using double ").
+        /// Appends characters directly to the shared buffer `sb`.
+        let rec readString () =
             match reader.Read() with
-            | -1 -> chars
+            | -1 -> ()
             | Quote when reader.Peek() = int quote ->
                 reader.Read() |> ignore
-                readString (chars.Append quote)
-            | Quote -> chars
-            | Char c -> readString (chars.Append c)
+                sb.Append quote |> ignore
+                readString ()
+            | Quote -> ()
+            | Char c ->
+                sb.Append c |> ignore
+                readString ()
 
         /// Reads a line with data that are separated using specified separators
         /// and may be quoted. Ends with newline or end of input.
-        let rec readLine data (chars: StringBuilder) current =
+        /// Accumulates fields into `fields` (a ResizeArray) using the shared `sb`.
+        let rec readLine (fields: ResizeArray<string>) current =
             match current with
             | -1
             | Char '\r'
             | Char '\n' ->
-                let item = chars.ToString()
-                item :: data
+                fields.Add(sb.ToString())
+                sb.Clear() |> ignore
             | Separator ->
-                let item = chars.ToString()
-                readLine (item :: data) (StringBuilder()) (reader.Read())
-            | Quote -> readLine data (readString chars) (reader.Read())
-            | Char c -> readLine data (chars.Append c) (reader.Read())
+                fields.Add(sb.ToString())
+                sb.Clear() |> ignore
+                readLine fields (reader.Read())
+            | Quote ->
+                readString ()
+                readLine fields (reader.Read())
+            | Char c ->
+                sb.Append c |> ignore
+                readLine fields (reader.Read())
 
         /// Reads multiple lines from the input, skipping newline characters
         let rec readLines lineNumber =
@@ -70,7 +83,9 @@ module internal CsvReader =
             | Char '\n' -> readLines lineNumber
             | current ->
                 seq {
-                    yield readLine [] (StringBuilder()) current |> List.rev |> Array.ofList, lineNumber
+                    let fields = ResizeArray<string>()
+                    readLine fields current
+                    yield fields.ToArray(), lineNumber
 
                     yield! readLines (lineNumber + 1)
                 }