Merge pull request #54 from lukasz-pyrzyk/develop

Version 2.0

Author: YPermitin

README.md

@@ -23,6 +23,9 @@ BinaryFormatter is a byte serialized/deserializer for .NET Core, created for Dis
   - classes
   - collections
   - structures
+  - guid
+  - uri
+  - enum
 
  ### Not supported types
 - IDictionary collections

appveyor.yml

@@ -1,4 +1,4 @@
-version: 1.2.0.{build}
+version: 2.0.0.{build}
 image: Visual Studio 2017
 
 environment:

src/BinaryFormatter/BinaryConverter.cs

@@ -1,19 +1,15 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 using BinaryFormatter.TypeConverter;
 using BinaryFormatter.Types;
 using System.Collections;
 using System.IO;
+using BinaryFormatter.Utils;
 
 namespace BinaryFormatter
 {
     public class BinaryConverter
     {
-        private static readonly List<string> excludedDlls = new List<string> { "CoreLib", "mscorlib" };
-        private static readonly ConvertersSelector _selector = new ConvertersSelector();
-
         public byte[] Serialize(object obj)
         {
             var stream = new MemoryStream();
@@ -23,55 +19,37 @@ public byte[] Serialize(object obj)
 
         public void Serialize(object obj, Stream stream)
         {
-            if (obj == null) return;
-
-            BaseTypeConverter converter = _selector.SelectConverter(obj);
-            if (converter != null)
-            {
-                converter.Serialize(obj, stream);
-            }
-            else
-            {
-                SerializePropertiesToStream(obj, stream);
-            }
+            BaseTypeConverter converter = ConvertersSelector.SelectConverter(obj);
+            converter.Serialize(obj, stream);
         }
 
-        private void SerializePropertiesToStream(object obj, Stream stream)
+        public T Deserialize<T>(byte[] stream)
         {
-            Type t = obj.GetType();
-            ICollection<PropertyInfo> properties = t.GetTypeInfo().DeclaredProperties.ToArray();
+            var workingStream = new WorkingStream(stream);
 
-            foreach (PropertyInfo property in properties)
+            SerializedType deserializedType = workingStream.ReadSerializedType();
+            if (deserializedType == SerializedType.Null)
             {
-                object prop = property.GetValue(obj);
-                Serialize(prop, stream);
+                return default(T);
             }
-        }
-
-        public T Deserialize<T>(byte[] stream)
-        {
-            Type type = typeof(T);
 
-            BaseTypeConverter converter = _selector.SelectConverter(type);
-            if (converter == null)
+            Type sourceType = deserializedType.GetBaseType();
+            if (sourceType == null)
             {
-                T instance = (T)Activator.CreateInstance(type);
-
-                int offset = 0;
-                DeserializeObject(stream, ref instance, ref offset);
-
-                return instance;
+                byte[] typeInfo = workingStream.ReadBytesWithSizePrefix();
+                sourceType = TypeUtils.FromUTF8Bytes(typeInfo);
             }
 
+            BaseTypeConverter converter = ConvertersSelector.SelectConverter(sourceType);
             if (converter is IEnumerableConverter)
             {
-                var prepearedData = converter.DeserializeToObject(stream) as IEnumerable;
+                var preparedData = converter.DeserializeToObject(stream) as IEnumerable;
 
                 var listType = typeof(List<>);
-                var genericArgs = type.GenericTypeArguments;
+                var genericArgs = sourceType.GenericTypeArguments;
                 var concreteType = listType.MakeGenericType(genericArgs);
                 var data = Activator.CreateInstance(concreteType);
-                foreach (var item in prepearedData)
+                foreach (var item in preparedData)
                 {
                     ((IList)data).Add(item);
                 }
@@ -80,64 +58,6 @@ public T Deserialize<T>(byte[] stream)
 
             return (T)converter.DeserializeToObject(stream);
         }
-
-        private void DeserializeObject<T>(byte[] stream, ref T instance, ref int offset)
-        {
-            foreach (PropertyInfo property in instance.GetType().GetTypeInfo().DeclaredProperties)
-            {
-                DeserializeProperty(property, ref instance, stream, ref offset);
-                if (offset == stream.Length)
-                    return;
-            }
-        }
-
-        private void DeserializeProperty<T>(PropertyInfo property, ref T instance, byte[] stream, ref int offset)
-        {
-            if (!excludedDlls.Any(x => property.PropertyType.AssemblyQualifiedName.Contains(x)))
-            {
-                object propertyValue = Activator.CreateInstance(property.PropertyType);
-                property.SetValue(instance, propertyValue);
-                DeserializeObject(stream, ref propertyValue, ref offset);
-                return;
-            }
-
-            Type instanceType = typeof(T);
-            TypeInfo instanceTypeInfo = instanceType.GetTypeInfo();
-            SerializedType type = (SerializedType)BitConverter.ToInt16(stream, offset);
-            offset += sizeof(short);
-
-            BaseTypeConverter converter = _selector.ForSerializedType(type);
-            object data;
-            if (type == SerializedType.IEnumerable)
-            {
-                var prepearedData = converter.DeserializeToObject(stream, ref offset) as IEnumerable;
-
-                var prop = property;
-                var listType = typeof(List<>);
-                var genericArgs = prop.PropertyType.GenericTypeArguments;
-                var concreteType = listType.MakeGenericType(genericArgs);
-                data = Activator.CreateInstance(concreteType);
-                foreach (var item in prepearedData)
-                {
-                    ((IList)data).Add(item);
-                }
-            }
-            else
-            {
-                data = converter.DeserializeToObject(stream, ref offset);
-            }
-
-            if (instanceTypeInfo.IsValueType && !instanceTypeInfo.IsPrimitive)
-            {
-                object boxedInstance = (object)instance;
-                property.SetValue(boxedInstance, data, property.GetIndexParameters());
-                instance = (T)boxedInstance;
-            }
-            else
-            {
-                property.SetValue(instance, data, property.GetIndexParameters());
-            }
-        }
     }
 }
 

src/BinaryFormatter/BinaryFormatter.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>BinaryFormatter - easy and light binary serializer</Description>
     <Copyright>Łukasz Pyrzyk</Copyright>
-    <VersionPrefix>1.2.0</VersionPrefix>
+    <VersionPrefix>2.0.0</VersionPrefix>
     <Authors>Łukasz Pyrzyk</Authors>
     <TargetFrameworks>netstandard1.1</TargetFrameworks>
     <AssemblyName>BinaryFormatter</AssemblyName>

src/BinaryFormatter/ConvertersSelector.cs

@@ -28,18 +28,30 @@ internal class ConvertersSelector
             [typeof(string)] = new StringConverter(),
             [typeof(DateTime)] = new DatetimeConverter(),
             [typeof(byte[])] = new ByteArrayConverter(),
-            [typeof(IEnumerable)] = new IEnumerableConverter()
+            [typeof(IEnumerable)] = new IEnumerableConverter(),
+            [typeof(object)] = new CustomObjectConverter(),
+            [typeof(Guid)] = new GuidConverter(),
+            [typeof(Uri)] = new UriConverter(),
+            [typeof(Enum)] = new EnumConverter()
         };
+        private static readonly BaseTypeConverter NullConverter = new NullConverter();
 
-        public BaseTypeConverter SelectConverter(object obj)
+        private ConvertersSelector()
         {
-            if(obj == null) return null;
+        }
+
+        public static BaseTypeConverter SelectConverter(object obj)
+        {
+            if (obj == null) return NullConverter;
+
             Type type = obj.GetType();
             return SelectConverter(type);
         }
 
-        public BaseTypeConverter SelectConverter(Type type)
+        public static BaseTypeConverter SelectConverter(Type type)
         {
+            if (type == null) return NullConverter;
+
             BaseTypeConverter converter;
             if (_converters.TryGetValue(type, out converter))
             {
@@ -55,11 +67,23 @@ public BaseTypeConverter SelectConverter(Type type)
                 }
             }
 
-            return null;
+            bool isEnumType = type.GetTypeInfo().IsEnum;
+            if (isEnumType)
+            {
+                if (_converters.TryGetValue(typeof(Enum), out converter))
+                {
+                    return converter;
+                }
+            }
+
+            return ForSerializedType(SerializedType.CustomObject);
         }
 
-        public BaseTypeConverter ForSerializedType(SerializedType type)
+        public static BaseTypeConverter ForSerializedType(SerializedType type)
         {
+            if (type == SerializedType.Null)
+                return NullConverter;
+
             return _converters.First(x => x.Value.Type == type).Value;
         }
     }

src/BinaryFormatter/TypeConverter/BaseTypeConverter.cs

@@ -2,37 +2,55 @@
 using System.IO;
 using BinaryFormatter.Types;
 using BinaryFormatter.Utils;
+using System.Text;
+using System.Reflection;
 
 namespace BinaryFormatter.TypeConverter
 {
     internal abstract class BaseTypeConverter<T> : BaseTypeConverter
     {
         public void Serialize(T obj, Stream stream)
         {
-            if (obj == null) throw new ArgumentNullException(nameof(obj));
-
+            Type destinationnType = typeof(T);
             byte[] objectType = BitConverter.GetBytes((ushort)Type);
             stream.Write(objectType);
 
-            WriteObjectToStream(obj, stream);
+            if (obj != null)
+            {
+                if (!destinationnType.GetTypeInfo().IsBaseType())
+                {
+                    byte[] typeInfo = Encoding.UTF8.GetBytes(obj.GetType().AssemblyQualifiedName);
+                    stream.WriteWithLengthPrefix(typeInfo);
+                }
+
+                WriteObjectToStream(obj, stream);
+            }
         }
 
         public override void Serialize(object obj, Stream stream)
         {
-            if (obj == null) throw new ArgumentNullException(nameof(obj));
-
             Serialize((T)obj, stream);
         }
 
-        public T Deserialize(byte[] stream)
+        public T Deserialize(byte[] bytes)
         {
-            int offset = sizeof (short);
-            return ProcessDeserialize(stream, ref offset);
+            var stream = new WorkingStream(bytes);
+            SerializedType deserializedType = stream.ReadSerializedType();
+            Type sourceType = deserializedType.GetBaseType();
+
+            if (sourceType == null)
+            {
+                byte[] typeInfo = stream.ReadBytesWithSizePrefix();
+                sourceType = TypeUtils.FromUTF8Bytes(typeInfo);
+            }
+
+            int offset = stream.Offset;
+            return ProcessDeserialize(bytes, sourceType, ref offset);
         }
 
-        public T Deserialize(byte[] stream, ref int offset)
+        public T Deserialize(byte[] bytes, ref int offset)
         {
-            T obj = ProcessDeserialize(stream, ref offset);
+            T obj = ProcessDeserialize(bytes, typeof(T), ref offset);
             offset += GetTypeSize();
             return obj;
         }
@@ -49,14 +67,7 @@ public override object DeserializeToObject(byte[] stream, ref int offset)
 
         protected abstract int GetTypeSize();
         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)
-        {
-            short type = BitConverter.ToInt16(stream, offset);
-            offset += sizeof (short);
-            return (SerializedType)type;
-        }
+        protected abstract T ProcessDeserialize(byte[] bytes, Type sourceType, ref int offset);
     }
 
     internal abstract class BaseTypeConverter

src/BinaryFormatter/TypeConverter/BoolConverter.cs

@@ -13,9 +13,9 @@ protected override void WriteObjectToStream(bool obj, Stream stream)
             stream.Write(data);
         }
 
-        protected override bool ProcessDeserialize(byte[] stream, ref int offset)
+        protected override bool ProcessDeserialize(byte[] bytes, Type sourceType, ref int offset)
         {
-            bool result = BitConverter.ToBoolean(stream, offset);
+            bool result = BitConverter.ToBoolean(bytes, offset);
             return result;
         }
 

src/BinaryFormatter/TypeConverter/ByteArrayConverter.cs

@@ -16,13 +16,13 @@ protected override void WriteObjectToStream(byte[] obj, Stream stream)
             stream.WriteWithLengthPrefix(obj);
         }
 
-        protected override byte[] ProcessDeserialize(byte[] stream, ref int offset)
+        protected override byte[] ProcessDeserialize(byte[] bytes, Type sourceType, ref int offset)
         {
-            int size = BitConverter.ToInt32(stream, offset);
+            int size = BitConverter.ToInt32(bytes, offset);
             offset += sizeof(int);
 
             byte[] deserialized = new byte[size];
-            Array.Copy(stream, offset, deserialized, 0, size);
+            Array.Copy(bytes, offset, deserialized, 0, size);
             return deserialized;
         }
 

src/BinaryFormatter/TypeConverter/ByteConverter.cs

@@ -13,9 +13,9 @@ protected override void WriteObjectToStream(byte obj, Stream stream)
             stream.Write(data);
         }
 
-        protected override byte ProcessDeserialize(byte[] stream, ref int offset)
+        protected override byte ProcessDeserialize(byte[] bytes, Type sourceType, ref int offset)
         {
-            return (byte)BitConverter.ToUInt16(stream, offset);
+            return (byte)BitConverter.ToUInt16(bytes, offset);
         }
 
         protected override int GetTypeSize()

src/BinaryFormatter/TypeConverter/CharConverter.cs

@@ -13,9 +13,9 @@ protected override void WriteObjectToStream(char obj, Stream stream)
             stream.Write(data);
         }
 
-        protected override char ProcessDeserialize(byte[] stream, ref int offset)
+        protected override char ProcessDeserialize(byte[] bytes, Type sourceType, ref int offset)
         {
-            char result = BitConverter.ToChar(stream, offset);
+            char result = BitConverter.ToChar(bytes, offset);
             return result;
         }