Avoid 1 element array alloc per child in open xml element.copy children (#2080)

Append(element.CloneNode(deep)) was resolving to the
  Append(params OpenXmlElement[]) overload, which allocates a fresh
  1-element array per cloned child. Switching to AppendChild eliminates
that array. Adds a CloneNode benchmark covering several element shapes;
  deep clones now allocate ~20% fewer bytes:

    Run_Deep                       952 →   792 B  (-17%)
    Paragraph_Simple_Deep          832 →   640 B  (-23%)
    Paragraph_Formatted_Deep     2,176 → 1,728 B  (-21%)
    Body_TenParagraphs_Deep     11,129 → 8,889 B  (-20%)
    Body_HundredParagraphs_Deep 110,495 → 88,094 B (-20%, -8% time)

Author: SimonCropp

src/DocumentFormat.OpenXml.Framework/OpenXmlElement.cs

@@ -1936,9 +1936,13 @@ private static MarkupCompatibilityAttributes CloneMCAttributes(MarkupCompatibili
         // Copy child elements from the container.
         internal void CopyChildren(OpenXmlElement container, bool deep)
         {
+            // Use AppendChild rather than Append: with a single OpenXmlElement argument the
+            // Append(params OpenXmlElement[]) overload allocates a 1-element array per child.
+            // For deep clones over a wide subtree those add up to a meaningful share of the
+            // CloneNode(true) allocation profile.
             foreach (var element in container.ChildElements)
             {
-                Append(element.CloneNode(deep));
+                AppendChild(element.CloneNode(deep));
             }
         }
 

test/DocumentFormat.OpenXml.Benchmarks/CloneNodeTests.cs

@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using BenchmarkDotNet.Attributes;
+using DocumentFormat.OpenXml.Wordprocessing;
+
+namespace DocumentFormat.OpenXml.Benchmarks;
+
+/// <summary>
+/// Benchmarks <see cref="OpenXmlElement.CloneNode(bool)"/> across several representative element
+/// shapes — leaf text, formatted run, simple paragraph, paragraph with properties, and a wider
+/// body. Loop-driven docx renderers (e.g. Parchment) call <c>CloneNode(true)</c> once per loop
+/// iteration so each iteration's allocation profile dominates the render's GC cost.
+/// </summary>
+public class CloneNodeTests
+{
+    private Text _text = null!;
+    private Run _runWithFormatting = null!;
+    private Paragraph _simpleParagraph = null!;
+    private Paragraph _formattedParagraph = null!;
+    private Body _bodyOfTen = null!;
+    private Body _bodyOfHundred = null!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _text = new Text("Hello world");
+
+        _runWithFormatting = new Run(
+            new RunProperties(
+                new RunFonts { Ascii = "Calibri" },
+                new FontSize { Val = "22" },
+                new Bold()),
+            new Text("Some formatted text"));
+
+        _simpleParagraph = new Paragraph(
+            new Run(new Text("First run")),
+            new Run(new Text(" second run")),
+            new Run(new Text(" third run")));
+
+        _formattedParagraph = new Paragraph(
+            new ParagraphProperties(
+                new ParagraphStyleId { Val = "Normal" },
+                new Justification { Val = JustificationValues.Left },
+                new SpacingBetweenLines { Before = "0", After = "200" }),
+            new Run(
+                new RunProperties(new Bold()),
+                new Text("Bold lead-in")),
+            new Run(new Text(" body text continues")),
+            new Run(
+                new RunProperties(new Italic()),
+                new Text(" italic tail")));
+
+        _bodyOfTen = BuildBody(10);
+        _bodyOfHundred = BuildBody(100);
+    }
+
+    [Benchmark]
+    public OpenXmlElement Text_Shallow() => _text.CloneNode(false);
+
+    [Benchmark]
+    public OpenXmlElement Text_Deep() => _text.CloneNode(true);
+
+    [Benchmark]
+    public OpenXmlElement Run_Shallow() => _runWithFormatting.CloneNode(false);
+
+    [Benchmark]
+    public OpenXmlElement Run_Deep() => _runWithFormatting.CloneNode(true);
+
+    [Benchmark]
+    public OpenXmlElement Paragraph_Simple_Deep() => _simpleParagraph.CloneNode(true);
+
+    [Benchmark]
+    public OpenXmlElement Paragraph_Formatted_Deep() => _formattedParagraph.CloneNode(true);
+
+    [Benchmark]
+    public OpenXmlElement Body_TenParagraphs_Deep() => _bodyOfTen.CloneNode(true);
+
+    [Benchmark]
+    public OpenXmlElement Body_HundredParagraphs_Deep() => _bodyOfHundred.CloneNode(true);
+
+    private static Body BuildBody(int paragraphCount)
+    {
+        var body = new Body();
+        for (var i = 0; i < paragraphCount; i++)
+        {
+            body.AppendChild(new Paragraph(
+                new ParagraphProperties(
+                    new ParagraphStyleId { Val = "Normal" }),
+                new Run(
+                    new RunProperties(new RunFonts { Ascii = "Calibri" }),
+                    new Text($"Paragraph {i} text content"))));
+        }
+
+        return body;
+    }
+}