Merge pull request #51 from esskar/develop

Develop

src/Serialize.Linq.Tests/Issues/Issue50.cs

@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Serialize.Linq.Serializers;
+
+namespace Serialize.Linq.Tests.Issues
+{
+    [TestClass]
+    public class Issue50
+    {
+        [TestMethod]
+        public void SerializeArrayAsJson()
+        {
+            var list = new [] { "one", "two" };
+            Expression<Func<Test, bool>> expression = test => list.Contains(test.Code);
+
+            var serializer = new ExpressionSerializer(new JsonSerializer());
+            var value = serializer.SerializeText(expression);
+
+            Assert.IsNotNull(value);
+        }
+
+        [TestMethod]
+        public void SerializeArrayAsBinary()
+        {
+            var list = new[] { "one", "two" };
+            Expression<Func<Test, bool>> expression = test => list.Contains(test.Code);
+
+            var serializer = new ExpressionSerializer(new BinarySerializer());
+            var value = serializer.SerializeBinary(expression);
+
+            Assert.IsNotNull(value);
+        }
+
+        [TestMethod]
+        public void SerializeListAsJson()
+        {
+            var list = new List<string> { "one", "two" };
+            Expression<Func<Test, bool>> expression = test => list.Contains(test.Code);
+
+            var serializer = new ExpressionSerializer(new JsonSerializer())
+            {
+                AutoAddKnownTypesAsListTypes = true
+            };
+            var value = serializer.SerializeText(expression);
+
+            Assert.IsNotNull(value);
+        }
+
+        [TestMethod]
+        public void SerializeListAsBinary()
+        {
+            var list = new List<string> { "one", "two" };
+            Expression<Func<Test, bool>> expression = test => list.Contains(test.Code);
+
+            var serializer = new ExpressionSerializer(new BinarySerializer())
+            {
+                AutoAddKnownTypesAsListTypes = true
+            };
+            var value = serializer.SerializeBinary(expression);
+
+            Assert.IsNotNull(value);
+        }
+
+        [TestMethod]
+        public void SerializeDeserializeArrayAsJson()
+        {
+            var list = new[] { "one", "two" };
+            Expression<Func<Test, bool>> expression = test => list.Contains(test.Code);
+
+            var serializer = new ExpressionSerializer(new JsonSerializer());
+            var value = serializer.SerializeText(expression);
+
+            var actualExpression = (Expression<Func<Test, bool>>)serializer.DeserializeText(value);
+            var func = actualExpression.Compile();
+
+
+            Assert.IsTrue(func(new Test { Code = "one" }), "one failed.");
+            Assert.IsTrue(func(new Test { Code = "two" }), "two failed.");
+            Assert.IsFalse(func(new Test { Code = "three" }), "three failed.");
+        }
+
+        [TestMethod]
+        public void SerializeDeserializeArrayAsBinary()
+        {
+            var list = new[] { "one", "two" };
+            Expression<Func<Test, bool>> expression = test => list.Contains(test.Code);
+
+            var serializer = new ExpressionSerializer(new BinarySerializer());
+            var value = serializer.SerializeBinary(expression);
+
+            var actualExpression = (Expression<Func<Test, bool>>)serializer.DeserializeBinary(value);
+            var func = actualExpression.Compile();
+
+            Assert.IsTrue(func(new Test { Code = "one" }), "one failed.");
+            Assert.IsTrue(func(new Test { Code = "two" }), "two failed.");
+            Assert.IsFalse(func(new Test { Code = "three" }), "three failed.");
+        }
+
+        public class Test
+        {
+            public string Code { get; set; }
+        }
+    }
+}

src/Serialize.Linq.Tests/Serialize.Linq.Tests.csproj

@@ -106,6 +106,7 @@
     <Compile Include="Issues\Issue39.cs" />
     <Compile Include="Issues\Issue41.cs" />
     <Compile Include="Issues\Issue43.cs" />
+    <Compile Include="Issues\Issue50.cs" />
     <Compile Include="MemberInfoExtensionsTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

src/Serialize.Linq/Interfaces/ISerializer.cs

@@ -15,6 +15,24 @@ namespace Serialize.Linq.Interfaces
 {
     public interface ISerializer
     {
+        /// <summary>
+        /// If set to true, and types are added as known types, also adds the type as array
+        /// Example: string -> string[] 
+        /// </summary>
+        /// <remarks>
+        /// If set to true, <see cref="AutoAddKnownTypesAsListTypes"/> will be set to false.
+        /// </remarks>
+        bool AutoAddKnownTypesAsArrayTypes { get; set; }
+
+        /// <summary>
+        /// If set to true, and types are added as known types, also adds the type as list
+        /// Example: string -> List&lt;string&gt;
+        /// </summary>
+        /// <remarks>
+        /// If set to true, <see cref="AutoAddKnownTypesAsArrayTypes"/> will be set to false.
+        /// </remarks>
+        bool AutoAddKnownTypesAsListTypes { get; set; }
+
         /// <summary>
         /// Adds a new type to the list of known types.
         /// </summary>

src/Serialize.Linq/Serializers/ExpressionSerializer.cs

@@ -7,6 +7,7 @@
 #endregion
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq.Expressions;
 using Serialize.Linq.Interfaces;
@@ -25,6 +26,18 @@ public ExpressionSerializer(ISerializer serializer)
             _serializer = serializer;            
         }
 
+        public bool AutoAddKnownTypesAsArrayTypes
+        {
+            get { return _serializer.AutoAddKnownTypesAsArrayTypes; }
+            set { _serializer.AutoAddKnownTypesAsArrayTypes = value; }
+        }
+
+        public bool AutoAddKnownTypesAsListTypes
+        {
+            get { return _serializer.AutoAddKnownTypesAsListTypes; }
+            set { _serializer.AutoAddKnownTypesAsListTypes = value; }
+        }
+
         public bool CanSerializeText
         {
             get { return _serializer is ITextSerializer; }
@@ -35,6 +48,16 @@ public bool CanSerializeBinary
             get { return _serializer is IBinarySerializer; }
         }
 
+        public void AddKnownType(Type type)
+        {
+            _serializer.AddKnownType(type);
+        }
+
+        public void AddKnownTypes(IEnumerable<Type> types)
+        {
+            _serializer.AddKnownTypes(types);
+        }
+
         public void Serialize(Stream stream, Expression expression)
         {
             if(stream == null)

src/Serialize.Linq/Serializers/SerializerBase.cs

@@ -23,10 +23,35 @@ public abstract class SerializerBase
         };
 
         private readonly HashSet<Type> _customKnownTypes;
+        private bool _autoAddKnownTypesAsArrayTypes;
+        private bool _autoAddKnownTypesAsListTypes;
 
         protected SerializerBase()
         {
             _customKnownTypes = new HashSet<Type>();
+            this.AutoAddKnownTypesAsArrayTypes = true;
+        }
+
+        public bool AutoAddKnownTypesAsArrayTypes
+        {
+            get { return _autoAddKnownTypesAsArrayTypes; }
+            set
+            {
+                _autoAddKnownTypesAsArrayTypes = value;
+                if (value)
+                    _autoAddKnownTypesAsListTypes = false;
+            }
+        }
+
+        public bool AutoAddKnownTypesAsListTypes
+        {
+            get { return _autoAddKnownTypesAsListTypes; }
+            set
+            {
+                _autoAddKnownTypesAsListTypes = value;
+                if (value)
+                    _autoAddKnownTypesAsArrayTypes = false;
+            }
         }
 
         public void AddKnownType(Type type)
@@ -48,15 +73,18 @@ public void AddKnownTypes(IEnumerable<Type> types)
 
         protected virtual IEnumerable<Type> GetKnownTypes()
         {
-            return ExplodeKnownTypes(_knownTypes).Concat(ExplodeKnownTypes(_customKnownTypes));
+            return this.ExplodeKnownTypes(_knownTypes).Concat(this.ExplodeKnownTypes(_customKnownTypes));
         }
 
-        private static IEnumerable<Type> ExplodeKnownTypes(IEnumerable<Type> types)
+        private IEnumerable<Type> ExplodeKnownTypes(IEnumerable<Type> types)
         {
             foreach (var type in types)
             {
                 yield return type;
-                yield return type.MakeArrayType();
+                if (this.AutoAddKnownTypesAsArrayTypes)
+                    yield return type.MakeArrayType();
+                else if (this.AutoAddKnownTypesAsListTypes)
+                    yield return typeof(List<>).MakeGenericType(type);
                 if (!type.IsClass)
                     yield return typeof(Nullable<>).MakeGenericType(type);
             }