All primitive converters with serialization based on stream

lukasz-pyrzyk · Jul 7, 2017 · 7206b6e · 7206b6e
1 parent 4cd3ab4
commit 7206b6e
Show file tree

Hide file tree

Showing 19 changed files with 99 additions and 64 deletions.
diff --git a/src/BinaryFormatter/TypeConverter/BaseTypeConverter.cs b/src/BinaryFormatter/TypeConverter/BaseTypeConverter.cs
@@ -11,11 +11,10 @@ public void Serialize(T obj, Stream stream)
         {
             if (obj == null) throw new ArgumentNullException(nameof(obj));
 
-            byte[] objectBytes = ProcessSerialize(obj);
             byte[] objectType = BitConverter.GetBytes((ushort)Type);
-
             stream.Write(objectType);
-            stream.Write(objectBytes);
+
+            WriteObjectToStream(obj, stream);
         }
 
         public override void Serialize(object obj, Stream stream)
@@ -49,7 +48,7 @@ public override object DeserializeToObject(byte[] stream, ref int offset)
         }
 
         protected abstract int GetTypeSize();
-        protected abstract byte[] ProcessSerialize(T obj);
+        protected abstract void WriteObjectToStream(T obj, Stream stream);
         protected abstract T ProcessDeserialize(byte[] stream, ref int offset);
 
         protected virtual SerializedType GetPackageType(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/BoolConverter.cs b/src/BinaryFormatter/TypeConverter/BoolConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class BoolConverter : BaseTypeConverter<bool>
     {
-        protected override byte[] ProcessSerialize(bool obj)
+        protected override void WriteObjectToStream(bool obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override bool ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/ByteArrayConverter.cs b/src/BinaryFormatter/TypeConverter/ByteArrayConverter.cs
@@ -1,22 +1,21 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class ByteArrayConverter : BaseTypeConverter<byte[]>
     {
         private int Size { get; set; }
 
-        protected override byte[] ProcessSerialize(byte[] obj)
+        protected override void WriteObjectToStream(byte[] obj, Stream stream)
         {
             Size = obj.Length;
             byte[] lengthBytes = BitConverter.GetBytes(Size);
 
-            byte[] serializedStringWithSize = new byte[sizeof(int) + Size];
-            Array.Copy(lengthBytes, 0, serializedStringWithSize, 0, lengthBytes.Length);
-            Array.Copy(obj, 0, serializedStringWithSize, lengthBytes.Length, obj.Length);
-
-            return serializedStringWithSize;
+            stream.Write(lengthBytes);
+            stream.Write(obj);
         }
 
         protected override byte[] ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/ByteConverter.cs b/src/BinaryFormatter/TypeConverter/ByteConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class ByteConverter : BaseTypeConverter<byte>
     {
-        protected override byte[] ProcessSerialize(byte obj)
+        protected override void WriteObjectToStream(byte obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override byte ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/CharConverter.cs b/src/BinaryFormatter/TypeConverter/CharConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class CharConverter : BaseTypeConverter<char>
     {
-        protected override byte[] ProcessSerialize(char obj)
+        protected override void WriteObjectToStream(char obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override char ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/DatetimeConverter.cs b/src/BinaryFormatter/TypeConverter/DatetimeConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class DatetimeConverter : BaseTypeConverter<DateTime>
     {
-        protected override byte[] ProcessSerialize(DateTime obj)
+        protected override void WriteObjectToStream(DateTime obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj.Ticks);
+            byte[] data = BitConverter.GetBytes(obj.Ticks);
+            stream.Write(data);
         }
 
         protected override DateTime ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/DecimalConverter.cs b/src/BinaryFormatter/TypeConverter/DecimalConverter.cs
@@ -1,7 +1,5 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Linq;
-using System.Text;
 using BinaryFormatter.Types;
 
 namespace BinaryFormatter.TypeConverter
@@ -10,14 +8,12 @@ internal class DecimalConverter : BaseTypeConverter<decimal>
     {
         private int Size { get; set; } = 0;
 
-        protected override byte[] ProcessSerialize(decimal obj)
+        protected override void WriteObjectToStream(decimal obj, Stream stream)
         {
             string sdecimal = obj.ToString("F");
             Size = sdecimal.Length;
-            var ms = new MemoryStream();
 
-            new StringConverter().Serialize(sdecimal, ms);
-            return ms.ToArray();
+            new StringConverter().Serialize(sdecimal, stream);
         }
 
         protected override decimal ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/DoubleConverter.cs b/src/BinaryFormatter/TypeConverter/DoubleConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class DoubleConverter : BaseTypeConverter<double>
     {
-        protected override byte[] ProcessSerialize(double obj)
+        protected override void WriteObjectToStream(double obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override double ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/FloatConverter.cs b/src/BinaryFormatter/TypeConverter/FloatConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class FloatConverter : BaseTypeConverter<float>
     {
-        protected override byte[] ProcessSerialize(float obj)
+        protected override void WriteObjectToStream(float obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override float ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/IEnumerableConverter.cs b/src/BinaryFormatter/TypeConverter/IEnumerableConverter.cs
@@ -1,22 +1,23 @@
 using System;
 using BinaryFormatter.Types;
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
 using System.Reflection;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class IEnumerableConverter : BaseTypeConverter<object>
     {
         private int Size { get; set; }
 
-        protected override byte[] ProcessSerialize(object obj)
+        protected override void WriteObjectToStream(object obj, Stream stream)
         {
-            byte[] collectionAsByteArray = null;
-            var objAsIEnumerable = (obj as IEnumerable<object>);
+            var objAsIEnumerable = obj as IEnumerable<object>;
             if (objAsIEnumerable != null)
             {
-                BinaryConverter converter = new BinaryConverter();        
+                BinaryConverter converter = new BinaryConverter();
                 List<byte> listAsArray = new List<byte>();
 
                 foreach (var sourceElementValue in objAsIEnumerable)
@@ -25,17 +26,19 @@ protected override byte[] ProcessSerialize(object obj)
                         continue;
 
                     object elementValue = (sourceElementValue as IEnumerable<object>);
-                    if(elementValue == null)
+                    if (elementValue == null)
                     {
                         elementValue = sourceElementValue;
-                    } else
+                    }
+                    else
                     {
                         List<object> collectionOfObjects = new List<object>();
-                        foreach (var item in (elementValue as IEnumerable<object>))
+                        foreach (var item in (IEnumerable<object>)elementValue)
                         {
                             collectionOfObjects.Add(item);
                         }
-                        elementValue = collectionOfObjects as IEnumerable<object>;
+
+                        elementValue = collectionOfObjects;
                     }
 
                     Type elementType = elementValue.GetType();
@@ -59,11 +62,10 @@ protected override byte[] ProcessSerialize(object obj)
                     listAsArray.AddRange(elementAsBytes);
                 }
 
-                collectionAsByteArray = listAsArray.ToArray();
+                byte[] collectionAsByteArray = listAsArray.ToArray();
                 Size = collectionAsByteArray.Length;
+                stream.Write(collectionAsByteArray);
             }
-
-            return collectionAsByteArray;
         }
 
         protected override object ProcessDeserialize(byte[] stream, ref int offset)
@@ -79,7 +81,7 @@ protected override object ProcessDeserialize(byte[] stream, ref int offset)
                 {
                     int sizeTypeInfo = BitConverter.ToInt32(stream, offset);
                     offset += sizeof(int);
-                    if(sizeTypeInfo == 0)
+                    if (sizeTypeInfo == 0)
                     {
                         continue;
                     }

diff --git a/src/BinaryFormatter/TypeConverter/IntConverter.cs b/src/BinaryFormatter/TypeConverter/IntConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class IntConverter : BaseTypeConverter<int>
     {
-        protected override byte[] ProcessSerialize(int obj)
+        protected override void WriteObjectToStream(int obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override int ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/LongConverter.cs b/src/BinaryFormatter/TypeConverter/LongConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class LongConverter : BaseTypeConverter<long>
     {
-        protected override byte[] ProcessSerialize(long obj)
+        protected override void WriteObjectToStream(long obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override long ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/SByteConverter.cs b/src/BinaryFormatter/TypeConverter/SByteConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class SByteConverter : BaseTypeConverter<sbyte>
     {
-        protected override byte[] ProcessSerialize(sbyte obj)
+        protected override void WriteObjectToStream(sbyte obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override sbyte ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/ShortConverter.cs b/src/BinaryFormatter/TypeConverter/ShortConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class ShortConverter : BaseTypeConverter<short>
     {
-        protected override byte[] ProcessSerialize(short obj)
+        protected override void WriteObjectToStream(short obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override short ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/StringConverter.cs b/src/BinaryFormatter/TypeConverter/StringConverter.cs
@@ -1,25 +1,23 @@
 using System;
+using System.IO;
 using System.Text;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class StringConverter : BaseTypeConverter<string>
     {
         private int Size { get; set; }
 
-        protected override byte[] ProcessSerialize(string obj)
+        protected override void WriteObjectToStream(string obj, Stream stream)
         {
             byte[] objBytes = Encoding.UTF8.GetBytes(obj);
             byte[] sizeBytes = BitConverter.GetBytes(objBytes.Length);
             Size = objBytes.Length;
 
-            byte[] serializedStringWithSize = new byte[sizeof(int) + objBytes.Length];
-
-            Array.ConstrainedCopy(sizeBytes, 0, serializedStringWithSize, 0, sizeBytes.Length);
-            Array.ConstrainedCopy(objBytes, 0, serializedStringWithSize, sizeBytes.Length, objBytes.Length);
-
-            return serializedStringWithSize;
+            stream.Write(sizeBytes);
+            stream.Write(objBytes);
         }
 
         protected override string ProcessDeserialize(byte[] stream, ref int offset)

diff --git a/src/BinaryFormatter/TypeConverter/UIntConverter.cs b/src/BinaryFormatter/TypeConverter/UIntConverter.cs
@@ -1,13 +1,16 @@
 using System;
+using System.IO;
 using BinaryFormatter.Types;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal class UIntConverter : BaseTypeConverter<uint>
     {
-        protected override byte[] ProcessSerialize(uint obj)
+        protected override void WriteObjectToStream(uint obj, Stream stream)
         {
-            return BitConverter.GetBytes(obj);
+            byte[] data = BitConverter.GetBytes(obj);
+            stream.Write(data);
         }
 
         protected override uint ProcessDeserialize(byte[] stream, ref int offset)