add CreateArrayBufferWriter methods to BufferFactory for non-pooled buffer writers

Author: polewskm

NCode.Buffers/BufferFactory.cs

@@ -324,4 +324,132 @@ public static Sequence<T> CreatePooledBufferWriter<T>(bool isSensitive, int mini
     /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="minimumSpanLength"/> is negative.</exception>
     public static Sequence<byte> CreatePooledBufferWriter(bool isSensitive, int minimumSpanLength = 0)
         => CreatePooledBufferWriter<byte>(isSensitive, minimumSpanLength);
+
+    /// <summary>
+    /// Creates a new <see cref="ArrayBufferWriter{T}"/> with the default initial capacity.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the buffer. Must be an unmanaged value type.</typeparam>
+    /// <returns>
+    /// A new <see cref="ArrayBufferWriter{T}"/> instance that implements <see cref="IBufferWriter{T}"/>.
+    /// </returns>
+    /// <remarks>
+    /// <para>
+    /// The returned <see cref="ArrayBufferWriter{T}"/> is a simple, non-pooled buffer writer that uses
+    /// a single contiguous array that grows as needed. Unlike <see cref="CreatePooledBufferWriter{T}"/>,
+    /// this method does not provide secure memory handling.
+    /// </para>
+    /// <para>
+    /// Use this method when you need a simple buffer writer for non-sensitive data and do not require
+    /// the overhead of memory pooling.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// using var writer = BufferFactory.CreateArrayBufferWriter&lt;int&gt;();
+    /// var span = writer.GetSpan(10);
+    /// // Write data to span
+    /// writer.Advance(10);
+    /// // Access the written data
+    /// ReadOnlySpan&lt;int&gt; data = writer.WrittenSpan;
+    /// </code>
+    /// </example>
+    public static ArrayBufferWriter<T> CreateArrayBufferWriter<T>()
+        where T : struct
+        => new();
+
+    /// <summary>
+    /// Creates a new <see cref="ArrayBufferWriter{T}"/> with the specified initial capacity.
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the buffer. Must be an unmanaged value type.</typeparam>
+    /// <param name="initialCapacity">The initial capacity of the underlying buffer.</param>
+    /// <returns>
+    /// A new <see cref="ArrayBufferWriter{T}"/> instance that implements <see cref="IBufferWriter{T}"/>.
+    /// </returns>
+    /// <remarks>
+    /// <para>
+    /// The returned <see cref="ArrayBufferWriter{T}"/> is a simple, non-pooled buffer writer that uses
+    /// a single contiguous array. Specifying an appropriate initial capacity can help reduce reallocations
+    /// when the expected data size is known in advance.
+    /// </para>
+    /// <para>
+    /// Unlike <see cref="CreatePooledBufferWriter{T}"/>, this method does not provide secure memory handling.
+    /// Use this method when you need a simple buffer writer for non-sensitive data.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// using var writer = BufferFactory.CreateArrayBufferWriter&lt;int&gt;(1024);
+    /// var span = writer.GetSpan(100);
+    /// // Write data to span
+    /// writer.Advance(100);
+    /// // Access the written data
+    /// ReadOnlySpan&lt;int&gt; data = writer.WrittenSpan;
+    /// </code>
+    /// </example>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="initialCapacity"/> is not positive.</exception>
+    public static ArrayBufferWriter<T> CreateArrayBufferWriter<T>(int initialCapacity)
+        where T : struct
+        => new(initialCapacity);
+
+    /// <summary>
+    /// Creates a new <see cref="ArrayBufferWriter{T}"/> for bytes with the default initial capacity.
+    /// </summary>
+    /// <returns>
+    /// A new <see cref="ArrayBufferWriter{T}"/> instance that implements <see cref="IBufferWriter{T}"/>.
+    /// </returns>
+    /// <remarks>
+    /// <para>
+    /// This is a convenience overload for the common case of working with byte buffers.
+    /// The returned <see cref="ArrayBufferWriter{T}"/> is a simple, non-pooled buffer writer that uses
+    /// a single contiguous array that grows as needed.
+    /// </para>
+    /// <para>
+    /// Unlike <see cref="CreatePooledBufferWriter(bool, int)"/>, this method does not provide secure memory handling.
+    /// Use this method when you need a simple buffer writer for non-sensitive byte data.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// using var writer = BufferFactory.CreateArrayBufferWriter();
+    /// var span = writer.GetSpan(100);
+    /// // Write byte data to span
+    /// writer.Advance(100);
+    /// // Access the written data
+    /// ReadOnlySpan&lt;byte&gt; data = writer.WrittenSpan;
+    /// </code>
+    /// </example>
+    public static ArrayBufferWriter<byte> CreateArrayBufferWriter()
+        => new();
+
+    /// <summary>
+    /// Creates a new <see cref="ArrayBufferWriter{T}"/> for bytes with the specified initial capacity.
+    /// </summary>
+    /// <param name="initialCapacity">The initial capacity of the underlying buffer.</param>
+    /// <returns>
+    /// A new <see cref="ArrayBufferWriter{T}"/> instance that implements <see cref="IBufferWriter{T}"/>.
+    /// </returns>
+    /// <remarks>
+    /// <para>
+    /// This is a convenience overload for the common case of working with byte buffers.
+    /// Specifying an appropriate initial capacity can help reduce reallocations when the expected
+    /// data size is known in advance.
+    /// </para>
+    /// <para>
+    /// Unlike <see cref="CreatePooledBufferWriter(bool, int)"/>, this method does not provide secure memory handling.
+    /// Use this method when you need a simple buffer writer for non-sensitive byte data.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// <code>
+    /// using var writer = BufferFactory.CreateArrayBufferWriter(1024);
+    /// var span = writer.GetSpan(100);
+    /// // Write byte data to span
+    /// writer.Advance(100);
+    /// // Access the written data
+    /// ReadOnlySpan&lt;byte&gt; data = writer.WrittenSpan;
+    /// </code>
+    /// </example>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="initialCapacity"/> is not positive.</exception>
+    public static ArrayBufferWriter<byte> CreateArrayBufferWriter(int initialCapacity)
+        => new(initialCapacity);
 }

README.md

@@ -26,6 +26,7 @@ A unified API for renting and creating secure memory buffers:
 - **Rent buffers** - Rent pooled buffers with optional secure zeroing on return
 - **Create pinned arrays** - Allocate GC-pinned arrays that are zeroed on disposal
 - **Create pooled buffer writers** - Build sequences incrementally with automatic secure disposal
+- **Create array buffer writers** - Simple, non-pooled buffer writers for general-purpose use
 
 ```csharp
 // Rent a sensitive buffer (pinned + zeroed on dispose)
@@ -40,6 +41,9 @@ Span<byte> pinnedBuffer = lifetime;
 using var writer = BufferFactory.CreatePooledBufferWriter<byte>(isSensitive: true);
 var span = writer.GetSpan(100);
 // Write data, then call writer.Advance(bytesWritten)
+
+// Create a simple array buffer writer (non-sensitive data)
+var arrayWriter = BufferFactory.CreateArrayBufferWriter<byte>(1024);
 ```
 
 #### SecureMemoryPool&lt;T&gt;
@@ -226,3 +230,4 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## Release Notes
 * v4.0.0 - Consolidated from other multiple projects.
+* v4.1.0 - Added `CreateArrayBufferWriter` methods to `BufferFactory` for simple, non-pooled buffer writers.