[Core] Refactored ZCompression to optimize GC

Author: Linwenxuan04

Lagrange.Core/Utility/Compression/Common.cs

@@ -4,7 +4,7 @@
 
 namespace Lagrange.Core.Utility.Compression;
 
-internal static class Common
+public static class Common
 {
     public static byte[] Deflate(byte[] data)
     {
@@ -14,21 +14,26 @@ public static byte[] Deflate(byte[] data)
         deflateStream.Close();
         return memoryStream.ToArray();
     }
-    
-    public static byte[] Inflate(ReadOnlySpan<byte> data)
+
+    public static byte[] Deflate(ReadOnlySpan<byte> data)
     {
-        using var ms = new MemoryStream();
-        using var ds = new DeflateStream(ms, CompressionMode.Decompress, true);
-        using var os = new MemoryStream();
+        using var memoryStream = new MemoryStream();
+        using var deflateStream = new DeflateStream(memoryStream, CompressionMode.Compress);
+        deflateStream.Write(data);
+        deflateStream.Close();
+        return memoryStream.ToArray();
+    }
 
-        ms.Write(data);
-        ms.Position = 0;
+    public static byte[] Inflate(ReadOnlySpan<byte> data)
+    {
+        using var input = new MemoryStream(data.Length);
+        input.Write(data);
+        input.Position = 0;
 
-        ds.CopyTo(os);
-        var deflate = new byte[os.Length];
-        os.Position = 0;
-        os.Read(deflate, 0, deflate.Length);
+        using var deflate = new DeflateStream(input, CompressionMode.Decompress);
+        using var output = new MemoryStream();
+        deflate.CopyTo(output);
 
-        return deflate;
+        return output.ToArray();
     }
 }

Lagrange.Core/Utility/Compression/ZCompression.cs

@@ -3,7 +3,7 @@
 
 namespace Lagrange.Core.Utility.Compression;
 
-internal static class ZCompression
+public static class ZCompression
 {
     public static byte[] ZCompress(byte[] data, byte[]? header = null)
     {
@@ -15,34 +15,52 @@ public static byte[] ZCompress(byte[] data, byte[]? header = null)
         stream.WriteByte(0xDA); // Zlib header
 
         stream.Write(deflate.AsSpan());
-        
-        var checksum = Adler32(data);
-        stream.Write(checksum.AsSpan());
-        
+
+        Span<byte> checksum = stackalloc byte[4];
+        BinaryPrimitives.WriteUInt32BigEndian(checksum, Adler32(data));
+        stream.Write(checksum);
+
         return stream.ToArray();
     }
-    
+
     public static byte[] ZCompress(string data, byte[]? header = null) => ZCompress(Encoding.UTF8.GetBytes(data), header);
 
+    public static byte[] ZCompress(ReadOnlySpan<byte> data, ReadOnlySpan<byte> header = default)
+    {
+        using var stream = new MemoryStream();
+        var deflate = Common.Deflate(data);
+
+        stream.Write(header);
+        stream.WriteByte(0x78); // Zlib header
+        stream.WriteByte(0xDA); // Zlib header
+
+        stream.Write(deflate.AsSpan());
+
+        Span<byte> checksum = stackalloc byte[4];
+        BinaryPrimitives.WriteUInt32BigEndian(checksum, Adler32(data));
+        stream.Write(checksum);
+
+        return stream.ToArray();
+    }
+
     public static byte[] ZDecompress(ReadOnlySpan<byte> data, bool validate = true)
     {
-        var checksum = data[^4..];
-        
+        uint expectedChecksum = BinaryPrimitives.ReadUInt32BigEndian(data[^4..]);
+
         var inflate = Common.Inflate(data[2..^4]);
-        if (validate) return checksum.SequenceEqual(Adler32(inflate)) ? inflate : throw new Exception("Checksum mismatch");
+        if (validate && Adler32(inflate) != expectedChecksum) throw new Exception("Checksum mismatch");
+
         return inflate;
     }
-        
-    private static byte[] Adler32(byte[] data)
+
+    private static uint Adler32(ReadOnlySpan<byte> data)
     {
         uint a = 1, b = 0;
         foreach (byte t in data)
         {
             a = (a + t) % 65521;
             b = (b + a) % 65521;
         }
-        var result = new byte[4];
-        BinaryPrimitives.WriteUInt32BigEndian(result, (b << 16) | a);
-        return result;
+        return (b << 16) | a;
     }
-}
+}