Merge pull request #7 from lukasz-pyrzyk/develop

lukasz-pyrzyk · web-flow · commit f20831b581ba · 2017-07-04T18:26:54.000+02:00
1.0.3
diff --git a/README.md b/README.md
@@ -21,9 +21,9 @@ BinaryFormatter is a byte serialized/deserializer for .NET Core, created for Dis
   - DateTime
   - byte[]
   - classes
+  - collections
 
  ### Not supported types
-  - Collections
   - structures
 
 
diff --git a/src/BinaryFormatter/BinaryConverter.cs b/src/BinaryFormatter/BinaryConverter.cs
@@ -4,6 +4,7 @@
 using System.Reflection;
 using BinaryFormatter.TypeConverter;
 using BinaryFormatter.Types;
+using System.Collections;
 
 namespace BinaryFormatter
 {
@@ -27,16 +28,24 @@ public class BinaryConverter
             [typeof(decimal)] = new DecimalConverter(),
             [typeof(string)] = new StringConverter(),
             [typeof(DateTime)] = new DatetimeConverter(),
-            [typeof(byte[])] = new ByteArrayConverter()
+            [typeof(byte[])] = new ByteArrayConverter(),
+            [typeof(IEnumerable)] = new IEnumerableConverter()
         };
 
         public byte[] Serialize(object obj)
         {
             Type t = obj.GetType();
+
             BaseTypeConverter converter;
             if (_converters.TryGetValue(t, out converter))
             {
                 return converter.Serialize(obj);
+            } else if (obj is IEnumerable)
+            {
+                if (_converters.TryGetValue(typeof(IEnumerable), out converter))
+                {
+                    return converter.Serialize(obj);
+                }
             }
 
             return SerializeProperties(obj);
@@ -63,25 +72,49 @@ private byte[] GetBytesFromProperty(object element)
             if (element == null) return new byte[0];
 
             Type t = element.GetType();
+            BaseTypeConverter converter;
             if (_converters.ContainsKey(t))
             {
-                BaseTypeConverter converter = _converters[t];
+                converter = _converters[t];
                 return converter.Serialize(element);
+            } else if (element is IEnumerable)
+            {
+                if (_converters.TryGetValue(typeof(IEnumerable), out converter))
+                {
+                    return converter.Serialize(element);
+                }
             }
 
-            // TODO serialize if IEnumerable
-
             return SerializeProperties(element);
         }
 
         public T Deserialize<T>(byte[] stream)
         {
             Type type = typeof(T);
 
+            bool isEnumerableType = type.GetTypeInfo().ImplementedInterfaces
+                .Where(t => t == typeof(IEnumerable)).Count() > 0;
+
             BaseTypeConverter converter;
             if (_converters.TryGetValue(type, out converter))
             {
-                return (T)converter.DeserializeToObject(stream);
+                return (T)converter.DeserializeToObject(stream);            
+            } else if (isEnumerableType)
+            {
+                if (_converters.TryGetValue(typeof(IEnumerable), out converter))
+                {                    
+                    var prepearedData = converter.DeserializeToObject(stream) as IEnumerable;
+
+                    var listType = typeof(List<>);
+                    var genericArgs = type.GenericTypeArguments;
+                    var concreteType = listType.MakeGenericType(genericArgs);
+                    var data = Activator.CreateInstance(concreteType);
+                    foreach (var item in prepearedData)
+                    {
+                        ((IList)data).Add(item);
+                    }
+                    return (T)data;
+                }
             }
 
             T instance = (T)Activator.CreateInstance(type);
@@ -116,8 +149,25 @@ private void DeserializeProperty<T>(PropertyInfo property, T instance, byte[] st
             offset += sizeof(short);
 
             BaseTypeConverter converter = _converters.First(x => x.Value.Type == type).Value;
-            object data = converter.DeserializeToObject(stream, ref offset);
-            property.SetValue(instance, data);
+            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);
+            }
+            property.SetValue(instance, data, property.GetIndexParameters());
         }
     }
 }
diff --git a/src/BinaryFormatter/BinaryFormatter.csproj b/src/BinaryFormatter/BinaryFormatter.csproj
@@ -2,17 +2,16 @@
 
   <PropertyGroup>
     <Description>BinaryFormatter - easy and light binary serializer</Description>
-    <Copyright>Lukasz Pyrzyk</Copyright>
-    <VersionPrefix>1.0.1</VersionPrefix>
-    <Authors>Lukasz Pyrzyk</Authors>
+    <Copyright>Łukasz Pyrzyk</Copyright>
+    <VersionPrefix>1.0.3</VersionPrefix>
+    <Authors>Łukasz Pyrzyk</Authors>
     <TargetFrameworks>netstandard1.1</TargetFrameworks>
     <AssemblyName>BinaryFormatter</AssemblyName>
     <PackageId>BinaryFormatter</PackageId>
     <PackageTags>binary serializer formatter deserializer serialization</PackageTags>
     <PackageIconUrl>https://raw.githubusercontent.com/lukasz-pyrzyk/BinaryFormatter/master/Nuget/nuget-icon.png</PackageIconUrl>
     <PackageProjectUrl>https://raw.githubusercontent.com/lukasz-pyrzyk/BinaryFormatter/</PackageProjectUrl>
     <PackageLicenseUrl>https://raw.githubusercontent.com/lukasz-pyrzyk/BinaryFormatter/master/License.txt</PackageLicenseUrl>
-    <NetStandardImplicitPackageVersion>1.6.1</NetStandardImplicitPackageVersion>
     <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
     <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
diff --git a/src/BinaryFormatter/Properties/AssemblyInfo.cs b/src/BinaryFormatter/Properties/AssemblyInfo.cs
@@ -10,7 +10,7 @@
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("BinaryFormatter")]
-[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 [assembly: InternalsVisibleTo("BinaryFormatterTests")]
diff --git a/src/BinaryFormatter/TypeConverter/IEnumerableConverter.cs b/src/BinaryFormatter/TypeConverter/IEnumerableConverter.cs
@@ -0,0 +1,120 @@
+﻿using System;
+using BinaryFormatter.Types;
+using System.Collections.Generic;
+using System.Text;
+using System.Reflection;
+
+namespace BinaryFormatter.TypeConverter
+{
+    internal class IEnumerableConverter : BaseTypeConverter<object>
+    {
+        private int Size { get; set; }
+
+        protected override byte[] ProcessSerialize(object obj)
+        {
+            byte[] collectionAsByteArray = null;
+            var objAsIEnumerable = (obj as IEnumerable<object>);
+            if (objAsIEnumerable != null)
+            {
+                BinaryConverter converter = new BinaryConverter();        
+                List<byte> listAsArray = new List<byte>();
+
+                foreach (var sourceElementValue in objAsIEnumerable)
+                {
+                    if (sourceElementValue == null)
+                        continue;
+
+                    object elementValue = (sourceElementValue as IEnumerable<object>);
+                    if(elementValue == null)
+                    {
+                        elementValue = sourceElementValue;
+                    } else
+                    {
+                        List<object> collectionOfObjects = new List<object>();
+                        foreach (var item in (elementValue as IEnumerable<object>))
+                        {
+                            collectionOfObjects.Add(item);
+                        }
+                        elementValue = collectionOfObjects as IEnumerable<object>;
+                    }
+
+                    Type elementType = elementValue.GetType();
+                    byte[] typeInfo = Encoding.UTF8.GetBytes(elementType.AssemblyQualifiedName);
+                    byte[] sizeTypeInfo = BitConverter.GetBytes(typeInfo.Length);
+
+                    byte[] data = converter.Serialize(elementValue);
+                    byte[] sizeData = BitConverter.GetBytes(data.Length);
+                    int elementAsBytesLength =
+                            sizeTypeInfo.Length +
+                            typeInfo.Length +
+                            sizeData.Length +
+                            data.Length;
+
+                    byte[] elementAsBytes = new byte[elementAsBytesLength];
+                    Array.Copy(sizeTypeInfo, 0, elementAsBytes, 0, sizeTypeInfo.Length);
+                    Array.Copy(typeInfo, 0, elementAsBytes, sizeTypeInfo.Length, typeInfo.Length);
+                    Array.Copy(sizeData, 0, elementAsBytes, sizeTypeInfo.Length + typeInfo.Length, sizeData.Length);
+                    Array.Copy(data, 0, elementAsBytes, sizeTypeInfo.Length + typeInfo.Length + sizeData.Length, data.Length);
+
+                    listAsArray.AddRange(elementAsBytes);
+                }
+
+                collectionAsByteArray = listAsArray.ToArray();
+                Size = collectionAsByteArray.Length;
+            }
+
+            return collectionAsByteArray;
+        }
+
+        protected override object ProcessDeserialize(byte[] stream, ref int offset)
+        {
+            List<object> deserializedCollection = null;
+
+            if (stream.Length > 0)
+            {
+                BinaryConverter converter = new BinaryConverter();
+                deserializedCollection = new List<object>();
+
+                while (offset < stream.Length)
+                {
+                    int sizeTypeInfo = BitConverter.ToInt32(stream, offset);
+                    offset += sizeof(int);
+                    if(sizeTypeInfo == 0)
+                    {
+                        continue;
+                    }
+
+                    byte[] typeInfo = new byte[sizeTypeInfo];
+                    Array.Copy(stream, offset, typeInfo, 0, sizeTypeInfo);
+                    string typeFullName = Encoding.UTF8.GetString(typeInfo, 0, sizeTypeInfo);
+                    Type valueType = System.Type.GetType(typeFullName);
+                    offset += sizeTypeInfo;
+
+                    int sizeData = BitConverter.ToInt32(stream, offset);
+                    offset += sizeof(int);
+                    if (sizeData == 0)
+                    {
+                        continue;
+                    }
+                    byte[] dataValue = new byte[sizeData];
+                    Array.Copy(stream, offset, dataValue, 0, sizeData);
+                    MethodInfo method = typeof(BinaryConverter).GetRuntimeMethod("Deserialize", new System.Type[] { typeof(byte[]) });
+                    method = method.MakeGenericMethod(valueType);
+                    object deserializeItem = method.Invoke(converter, new object[] { dataValue });
+                    offset += sizeData;
+
+                    deserializedCollection.Add(deserializeItem);
+                }
+            }
+
+            return deserializedCollection;
+        }
+
+        protected override int GetTypeSize()
+        {
+            return Size;
+        }
+
+        public override SerializedType Type => SerializedType.IEnumerable;
+    }
+}
diff --git a/src/BinaryFormatter/Types/SerializedType.cs b/src/BinaryFormatter/Types/SerializedType.cs
@@ -17,6 +17,7 @@ internal enum SerializedType : ushort
         Decimal = 13,
         String = 14,
         Datetime = 15,
-        ByteArray = 16
+        ByteArray = 16,
+        IEnumerable = 17
     }
 }
diff --git a/src/Tests/BinaryFormatterTests/BinaryConverterTests.cs b/src/Tests/BinaryFormatterTests/BinaryConverterTests.cs
@@ -2,6 +2,7 @@
 using System.Text;
 using BinaryFormatter;
 using Xunit;
+using System.Collections.Generic;
 
 namespace BinaryFormatterTests
 {
@@ -210,5 +211,19 @@ public void CanSerialize_ByteArray()
 
             Assert.Equal(value, deserializedValue);
         }
+
+        [Fact]
+        public void CanSerialize_IEnumerable()
+        {
+            List<string> value = new List<string>();
+            value.Add("lorem ipsum");
+            value.Add("Кто не ходит, тот и не падает.");
+
+            BinaryConverter converter = new BinaryConverter();
+            byte[] bytes = converter.Serialize(value);
+            List<string> deserializedValue = converter.Deserialize<List<string>>(bytes);
+
+            Assert.Equal(value, deserializedValue);
+        }
     }
 }
diff --git a/src/Tests/BinaryFormatterTests/BinaryFormatterTests.csproj b/src/Tests/BinaryFormatterTests/BinaryFormatterTests.csproj
@@ -24,4 +24,8 @@
     <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0-beta1-build3642" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
 </Project>
diff --git a/src/Tests/BinaryFormatterTests/Properties/AssemblyInfo.cs b/src/Tests/BinaryFormatterTests/Properties/AssemblyInfo.cs
@@ -10,7 +10,7 @@
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("BinaryFormatterTests")]
-[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
diff --git a/src/Tests/BinaryFormatterTests/TypeConverter/IEnumerableConverterTests.cs b/src/Tests/BinaryFormatterTests/TypeConverter/IEnumerableConverterTests.cs

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ internal enum SerializedType : ushort`
`17`	`17`	`Decimal = 13,`
`18`	`18`	`String = 14,`
`19`	`19`	`Datetime = 15,`
`20`		`- ByteArray = 16`
	`20`	`+ ByteArray = 16,`
	`21`	`+ IEnumerable = 17`
`21`	`22`	`}`
`22`	`23`	`}`