feat:

+ clear method and refactor for reuse memory and existing chain

Author: SoftStoneDevelop

Src/Benchmark/CompareStringBuilders.cs

@@ -5,7 +5,6 @@ namespace Benchmark
 {
     [MemoryDiagnoser]
     [SimpleJob(RuntimeMoniker.Net70)]
-    [SimpleJob(RuntimeMoniker.Net481)]
     [HideColumns("Error", "StdDev", "Median", "RatioSD")]
     public partial class CompareStringBuilders
     {

Src/Benchmark/CompareStringBuildersClear.cs

@@ -0,0 +1,58 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+
+namespace Benchmark
+{
+    [MemoryDiagnoser]
+    [SimpleJob(RuntimeMoniker.Net70)]
+    [HideColumns("Error", "StdDev", "Median", "RatioSD")]
+    public partial class CompareStringBuildersClear
+    {
+        [Params(5, 7, 10, 50, 100, 1000, 2500, 5_000, 10_000, 100_000, 500_000, 1_071_741)]
+        public int StrLength;
+
+        private string _str;
+
+        [IterationSetup]
+        public void Setup()
+        {
+            _str = new string('S', StrLength);
+        }
+
+        [Benchmark(Baseline = true, Description = "StringBuilder")]
+        public void StringBuilder()
+        {
+            var sb = new System.Text.StringBuilder();
+            for (int i = 0; i < 1000; i++)
+            {
+                sb.AppendLine(_str);
+            }
+
+            sb.Clear();
+            for (int i = 0; i < 1000; i++)
+            {
+                sb.AppendLine(_str);
+            }
+
+            var result = sb.ToString();
+        }
+
+        [Benchmark(Description = "StringBuilderArray")]
+        public void StringBuilderArray()
+        {
+            var sb = new StringBuilderArray.StringBuilderArray();
+            for (int i = 0; i < 1000; i++)
+            {
+                sb.AppendLine(_str);
+            }
+
+            sb.Clear();
+            for (int i = 0; i < 1000; i++)
+            {
+                sb.AppendLine(_str);
+            }
+
+            var result = sb.ToString();
+        }
+    }
+}

Src/Benchmark/Program.cs

@@ -7,6 +7,7 @@ internal class Program
         static void Main(string[] args)
         {
             BenchmarkRunner.Run<CompareStringBuilders>();
+            BenchmarkRunner.Run<CompareStringBuildersClear>();
         }
     }
 }

Src/StringBuilderArray/StringBuilderArray.cs

@@ -6,6 +6,7 @@ namespace StringBuilderArray
     public class StringBuilderArray
     {
         private StringBuilderArray _previous;
+        private StringBuilderArray _next;
         private string[] _buffer;
         private int _size;
         private int _length;
@@ -36,6 +37,10 @@ private StringBuilderArray(StringBuilderArray stringBuilderArray)
             _size = stringBuilderArray._size;
             _length = stringBuilderArray._length;
             _previous = stringBuilderArray._previous;
+            if(_previous != null)
+            {
+                _previous._next = this;
+            }
         }
 
         public int Length
@@ -60,14 +65,40 @@ public StringBuilderArray Append(string str)
         {
             if (_size == _buffer.Length)
             {
-                Grow();
+                MakeThisPrevious();
             }
-            
+
             _buffer[_size++] = str;
             _length += str.Length;
             return this;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void MakeThisPrevious()
+        {
+            if(_next != null)
+            {
+                _previous = new StringBuilderArray(this);
+                _next._previous = null;
+
+                _buffer = _next._buffer;
+                _next._buffer = null;
+
+                var tempNext = _next;
+                _next = _next._next;
+                tempNext._next = null;
+            }
+            else
+            {
+                _previous = new StringBuilderArray(this);
+                int newBufferLength = Math.Max(10, Math.Min(_buffer.Length * 2, MaxChunkSize));
+                _buffer = new string[newBufferLength];
+            }
+
+            _size = 0;
+            _length = 0;
+        }
+
         public StringBuilderArray AppendLine(string str)
         {
             Append(str);
@@ -96,15 +127,46 @@ public StringBuilderArray AppendLine(string[] strings)
             return this;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void Grow()
+        public StringBuilderArray Clear()
         {
-            _previous = new StringBuilderArray(this);
+            StringBuilderArray head = null;
+            var current = this;
+            do
+            {
+                head = current;
+                current._length = 0;
+                current._size = 0;
+#if NET6_0_OR_GREATER
+                Array.Clear(current._buffer);
+#else
+                Array.Clear(current._buffer, 0, current._buffer.Length);
+#endif
+                current = current._previous;
+            } while (current != null);
 
-            int newBufferLength = Math.Max(10, Math.Min(_buffer.Length * 2, MaxChunkSize));
-            _buffer = new string[newBufferLength];
+            current = this._next;
+            while (current != null)
+            {
+                current._length = 0;
+                current._size = 0;
+#if NET6_0_OR_GREATER
+                Array.Clear(current._buffer);
+#else
+                Array.Clear(current._buffer, 0, current._buffer.Length);
+#endif
+                current = current._next;
+            }
+
+            //make this head
+            _previous = null;
+            _next = head._next;
+            _buffer = head._buffer;
             _size = 0;
             _length = 0;
+            head._next = null;
+            head._previous = null;
+
+            return this;
         }
 
         public override string ToString()

Src/StringBuilderArray/StringBuilderArray.csproj

@@ -5,7 +5,7 @@
 	</PropertyGroup>
 	<PropertyGroup>
 		<PackageId>StringBuilderArray</PackageId>
-		<PackageVersion>1.0.0.1</PackageVersion>
+		<PackageVersion>1.1.0.0</PackageVersion>
 		<Authors>Brevnov Vyacheslav Sergeevich</Authors>
 		<RepositoryUrl>https://github.com/SoftStoneDevelop/StringBuilderArray</RepositoryUrl>
 		<PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>