Optimized: MemoryStream to not Allocate Heap Memory when Not Needed

Author: Sewer56

Source/Reloaded.Memory/Streams/ExtendedMemoryStream.cs

@@ -1,13 +1,17 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 
 namespace Reloaded.Memory.Streams
 {
     /// <summary>
     /// An extended version of the <see cref="MemoryStream"/> class that allows you to directly add generic structs to the stream.
     /// </summary>
-    public partial class ExtendedMemoryStream : MemoryStream
+    public unsafe partial class ExtendedMemoryStream : MemoryStream
     {
+        private const int MaxStackLimit = 1024;
+
         /// <inheritdoc />
         public ExtendedMemoryStream() { }
 
@@ -61,25 +65,78 @@ public void AddPadding(byte value, int alignment = 2048)
         /// Appends an unmanaged structure onto the <see cref="MemoryStream"/> and advances the position.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Write<T>(T[] structure) where T : unmanaged => Write(StructArray.GetBytes(structure));
+        public void Write<T>(T[] structure) where T : unmanaged
+        {
+            for (int x = 0; x < structure.Length; x++)
+                Write(ref structure[x]);
+        }
 
         /// <summary>
         /// Appends an managed/marshalled structure onto the <see cref="MemoryStream"/> and advances the position.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Write<T>(T[] structure, bool marshalStructure = true) => Write(StructArray.GetBytes(structure, marshalStructure));
+        public void Write<T>(T[] structure, bool marshalStructure = true)
+        {
+            for (int x = 0; x < structure.Length; x++)
+                Write(ref structure[x], marshalStructure);
+        }
 
         /// <summary>
         /// Appends an unmanaged structure onto the <see cref="MemoryStream"/> and advances the position.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Write<T>(T structure) where T : unmanaged => Write(Struct.GetBytes(structure));
+        public void Write<T>(T structure) where T : unmanaged => Write(ref structure);
+
+        /// <summary>
+        /// Appends an unmanaged structure onto the <see cref="MemoryStream"/> and advances the position.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write<T>(ref T structure) where T : unmanaged
+        {
+#if FEATURE_NATIVE_SPAN
+            if (sizeof(T) < MaxStackLimit)
+            {
+                Span<byte> stack = stackalloc byte[sizeof(T)];
+                Struct.GetBytes(ref structure, stack);
+                base.Write(stack);
+            }
+            else
+            {
+                Write(Struct.GetBytes(structure));
+            }
+#else
+            Write(Struct.GetBytes(structure));
+#endif
+        }
+
+        /// <summary>
+        /// Appends a managed/marshalled structure onto the given <see cref="MemoryStream"/> and advances the position.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Write<T>(T structure, bool marshalStructure = true) => Write(ref structure, marshalStructure);
 
         /// <summary>
         /// Appends a managed/marshalled structure onto the given <see cref="MemoryStream"/> and advances the position.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Write<T>(T structure, bool marshalStructure = true) => Write(Struct.GetBytes(structure, marshalStructure));
+        public void Write<T>(ref T structure, bool marshalStructure = true)
+        {
+#if FEATURE_NATIVE_SPAN
+            var size = Struct.GetSize<T>(true);
+            if (size < MaxStackLimit)
+            {
+                Span<byte> stack = stackalloc byte[size];
+                Struct.GetBytes(ref structure, marshalStructure, stack);
+                base.Write(stack);
+            }
+            else
+            {
+                Write(Struct.GetBytes(structure, marshalStructure));
+            }
+#else
+            Write(Struct.GetBytes(structure, marshalStructure));
+#endif
+        }
 
         /// <summary>
         /// Appends bytes onto the given <see cref="MemoryStream"/> and advances the position.
@@ -92,8 +149,8 @@ public void AddPadding(byte value, int alignment = 2048)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteBigEndianPrimitive<T>(T[] structures) where T : unmanaged
         {
-            foreach (var structure in structures)
-                WriteBigEndianPrimitive(structure);
+            for (var x = 0; x < structures.Length; x++)
+                WriteBigEndianPrimitive(structures[x]);
         }
 
         /// <summary>
@@ -102,8 +159,8 @@ public void WriteBigEndianPrimitive<T>(T[] structures) where T : unmanaged
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void WriteBigEndianStruct<T>(T[] structures) where T : unmanaged, IEndianReversible
         {
-            foreach (var structure in structures)
-                WriteBigEndianStruct(structure);
+            for (var x = 0; x < structures.Length; x++)
+                WriteBigEndianStruct(structures[x]);
         }
 
         /// <summary>
@@ -113,7 +170,7 @@ public void WriteBigEndianStruct<T>(T[] structures) where T : unmanaged, IEndian
         public void WriteBigEndianPrimitive<T>(T structure) where T : unmanaged
         {
             Endian.Reverse(ref structure);
-            Write(Struct.GetBytes(structure));
+            Write(ref structure);
         }
 
         /// <summary>
@@ -123,7 +180,7 @@ public void WriteBigEndianPrimitive<T>(T structure) where T : unmanaged
         public void WriteBigEndianStruct<T>(T structure) where T : unmanaged, IEndianReversible
         {
             structure.SwapEndian();
-            Write(Struct.GetBytes(structure));
+            Write(ref structure);
         }
 
         private static int RoundUp(int number, int multiple)

Source/Reloaded.Memory/Streams/Writers/LittleEndianMemoryStream.cs

@@ -19,7 +19,7 @@ public LittleEndianMemoryStream(ExtendedMemoryStream stream) : base(stream) { }
         public override void Write<T>(T[] structure) => Stream.Write(structure);
 
         /// <inheritdoc />
-        public override void Write<T>(T structure) => Stream.Write(structure);
+        public override void Write<T>(T structure) => Stream.Write(ref structure);
 
         /// <summary>
         /// Appends an managed/marshalled structure onto the <see cref="MemoryStream"/> and advances the position.
@@ -31,6 +31,6 @@ public LittleEndianMemoryStream(ExtendedMemoryStream stream) : base(stream) { }
         /// Appends a managed/marshalled structure onto the given <see cref="MemoryStream"/> and advances the position.
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void Write<T>(T structure, bool marshalStructure = true) => Stream.Write(structure, marshalStructure);
+        public void Write<T>(T structure, bool marshalStructure = true) => Stream.Write(ref structure, marshalStructure);
     }
 }