Update serializer to avoid using leaveOpen option

Author: scorteanucosmin

src/Common/Constants.cs

@@ -1,10 +1,12 @@
-using System.Text.RegularExpressions;
+using System.Text;
+using System.Text.RegularExpressions;
 
 namespace Oxide.CSharp.Common
 {
     internal static class Constants
     {
         internal static readonly Serializer Serializer = new();
+        internal static readonly UTF8Encoding CompilerEncoding = new(false);
 
         internal const string CompilerDownloadUrl = "https://downloads.oxidemod.com/artifacts/Oxide.Compiler/{0}/";
         internal const string CompilerBasicArguments = "-unsafe true --setting:Force true -ms true";

src/CompilerStream/MessageBrokerService.cs

@@ -91,13 +91,14 @@ private async Task WorkerAsync(CancellationToken cancellationToken)
         private void WriteMessage(CompilerMessage message)
         {
             byte[] headerBuffer = ArrayPool<byte>.Shared.Take(sizeof(int));
+
+            using MemoryStream memoryStream = new();
+            using StreamWriter streamWriter = new(memoryStream, Constants.CompilerEncoding, DefaultMaxBufferSize);
             try
             {
-                using MemoryStream memoryStream = new();
-                Constants.Serializer.SerializeToStream(memoryStream, message, DefaultMaxBufferSize);
+                Constants.Serializer.GetJsonSerializer().Serialize(streamWriter, message);
 
                 int length = (int)memoryStream.Length;
-
                 length.WriteBigEndian(headerBuffer);
 
                 _pipeServer.Write(headerBuffer, 0, sizeof(int));
@@ -109,6 +110,7 @@ private void WriteMessage(CompilerMessage message)
             }
             finally
             {
+                streamWriter.Flush();
                 ArrayPool<byte>.Shared.Return(headerBuffer);
             }
         }

src/Serializer.cs

@@ -1,43 +1,34 @@
 extern alias References;
 using System.IO;
-using System.Text;
+using Oxide.CSharp.Common;
 using References::Newtonsoft.Json;
 
 namespace Oxide.CSharp;
 
-public class Serializer
+internal class Serializer
 {
     private readonly JsonSerializer _jsonSerializer;
-    private readonly UTF8Encoding _encoding;
 
-    public Serializer()
+    internal Serializer()
     {
         _jsonSerializer = new JsonSerializer();
-        _encoding = new UTF8Encoding(false);
     }
 
-    public void SerializeToStream<T>(MemoryStream memoryStream, T type, int bufferSize) where T : class
-    {
-        using StreamWriter streamWriter = new(memoryStream, _encoding, bufferSize, leaveOpen: true);
-
-        _jsonSerializer.Serialize(streamWriter, type);
-
-        streamWriter.Flush();
-    }
-
-    public byte[] Serialize<T>(T type) where T : class
+    internal byte[] Serialize<T>(T type) where T : class
     {
         using MemoryStream memoryStream = new();
-        using StreamWriter streamWriter = new(memoryStream, _encoding);
+        using StreamWriter streamWriter = new(memoryStream, Constants.CompilerEncoding);
         _jsonSerializer.Serialize(streamWriter, type);
         streamWriter.Flush();
         return memoryStream.ToArray();
     }
 
-    public T Deserialize<T>(byte[] data) where T : class
+    internal T? Deserialize<T>(byte[] data) where T : class
     {
         using MemoryStream memoryStream = new(data);
-        using StreamReader streamReader = new(memoryStream, _encoding);
-        return (T)_jsonSerializer.Deserialize(streamReader, typeof(T));
+        using StreamReader streamReader = new(memoryStream, Constants.CompilerEncoding);
+        return (T?)_jsonSerializer.Deserialize(streamReader, typeof(T));
     }
+
+    internal JsonSerializer GetJsonSerializer() => _jsonSerializer;
 }