MemoryWriteStream: enforce single-flush semantics

PowerKit.Tests/MemoryWriteStreamTests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using FluentAssertions;
 using PowerKit.Tests.Utils;
@@ -29,4 +30,46 @@ public void MemoryWriteStream_Test()
         seekable.CanSeek.Should().BeTrue();
         destination.ToArray().Should().Equal(data);
     }
+
+    [Fact]
+    public void MemoryWriteStream_FlushTwice_Throws()
+    {
+        // Arrange
+        using var destination = new MemoryStream();
+        using var seekable = new MemoryWriteStream(destination);
+
+        seekable.Write([1, 2, 3]);
+        seekable.Flush();
+
+        // Act & Assert
+        seekable.Invoking(s => s.Flush()).Should().Throw<InvalidOperationException>();
+    }
+
+    [Fact]
+    public void MemoryWriteStream_WriteAfterFlush_Throws()
+    {
+        // Arrange
+        using var destination = new MemoryStream();
+        using var seekable = new MemoryWriteStream(destination);
+
+        seekable.Write([1, 2, 3]);
+        seekable.Flush();
+
+        // Act & Assert
+        seekable.Invoking(s => s.Write([4, 5, 6])).Should().Throw<InvalidOperationException>();
+    }
+
+    [Fact]
+    public void MemoryWriteStream_FlushThenDispose_DoesNotThrow()
+    {
+        // Arrange
+        using var destination = new MemoryStream();
+        var seekable = new MemoryWriteStream(destination);
+
+        seekable.Write([1, 2, 3]);
+        seekable.Flush();
+
+        // Act & Assert
+        seekable.Invoking(s => s.Dispose()).Should().NotThrow();
+    }
 }

PowerKit/MemoryWriteStream.cs

@@ -5,16 +5,17 @@ namespace PowerKit;
 
 /// <summary>
 /// A <see cref="Stream" /> wrapper that buffers all writes in memory and flushes them to the
-/// underlying stream on <see cref="Flush" />.
+/// underlying stream on <see cref="Flush()" />.
 /// </summary>
 /// <remarks>
 /// Writes go to an in-memory buffer and do not touch the underlying stream until
-/// <see cref="Flush" /> is called. This makes the wrapper always seekable and allows writes to
+/// <see cref="Flush()" /> is called. This makes the wrapper always seekable and allows writes to
 /// be reordered freely before the final flush.
 /// </remarks>
 public class MemoryWriteStream(Stream source) : Stream
 {
     private readonly MemoryStream _buffer = new();
+    private bool _isFlushed;
 
     /// <inheritdoc />
     public override bool CanRead => false;
@@ -35,12 +36,34 @@ public override long Position
         set => _buffer.Position = value;
     }
 
-    /// <inheritdoc />
-    public override void Flush()
+    private void Flush(bool throwIfAlreadyFlushed)
     {
+        if (_isFlushed)
+        {
+            if (throwIfAlreadyFlushed)
+            {
+                throw new InvalidOperationException(
+                    "This stream has already been flushed and cannot be flushed again."
+                );
+            }
+
+            return;
+        }
+
         _buffer.Position = 0;
         _buffer.CopyTo(source);
         source.Flush();
+        _isFlushed = true;
+    }
+
+    /// <inheritdoc />
+    public override void Flush() => Flush(true);
+
+    /// <inheritdoc />
+    protected override void Dispose(bool disposing)
+    {
+        Flush(false);
+        base.Dispose(disposing);
     }
 
     /// <inheritdoc />
@@ -54,6 +77,15 @@ public override int Read(byte[] buffer, int offset, int count) =>
         throw new NotSupportedException();
 
     /// <inheritdoc />
-    public override void Write(byte[] buffer, int offset, int count) =>
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        if (_isFlushed)
+        {
+            throw new InvalidOperationException(
+                "This stream has already been flushed and cannot be flushed again."
+            );
+        }
+
         _buffer.Write(buffer, offset, count);
+    }
 }