Add constructor resolution to datacontractresolver

src/Chr.Avro.Binary/BinaryDeserializerBuilder.cs

@@ -372,26 +372,63 @@ public override Delegate BuildDelegate(TypeResolution resolution, Schema schema,
                 ExceptionDispatchInfo.Capture(indirect.InnerException).Throw();
             }
 
-            var convert = typeof(Enumerable).GetMethods()
-                .Where(m => m.Name == (target.IsArray
-                    ? nameof(Enumerable.ToArray)
-                    : nameof(Enumerable.ToList)
-                ))
-                .Single()
-                .MakeGenericMethod(item);
-
-            if (!target.IsAssignableFrom(convert.ReturnType))
+            var constructor = FindEnumerableConstructor(arrayResolution, item);
+
+            if (constructor != null)
             {
-                throw new UnsupportedTypeException(target, $"An array deserializer cannot be built for type {target.FullName}.");
+                var value = Expression.Parameter(target);
+                result = Expression.Block(
+                    new[] { value },
+                    Expression.Assign(value, Expression.New(constructor.Constructor, new[] { result })),
+                    value
+                );
             }
+            else
+            {
+                var convert = typeof(Enumerable).GetMethods()
+                    .Where(m => m.Name == (target.IsArray
+                        ? nameof(Enumerable.ToArray)
+                        : nameof(Enumerable.ToList)
+                    ))
+                    .Single()
+                    .MakeGenericMethod(item);
 
-            result = Expression.ConvertChecked(Expression.Call(null, convert, result), target);
+                if (!target.IsAssignableFrom(convert.ReturnType))
+                {
+                    throw new UnsupportedTypeException(target, $"An array deserializer cannot be built for type {target.FullName}.");
+                }
+
+                result = Expression.ConvertChecked(Expression.Call(null, convert, result), target);
+            }
 
             var lambda = Expression.Lambda(result, "array deserializer", new[] { stream });
             var compiled = lambda.Compile();
 
             return cache.GetOrAdd((target, schema), compiled);
         }
+
+        private ConstructorResolution FindEnumerableConstructor(ArrayResolution arrayResolution, Type type)
+        {
+            ConstructorResolution match = null;
+            foreach (var constructor in arrayResolution.Constructors)
+            {
+                if (constructor.Parameters.Count == 1)
+                {
+                    var parameterType = constructor.Parameters.First().Type;
+                    if (parameterType.IsGenericType && parameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+                    {
+                        var arguments = parameterType.GetGenericArguments();
+                        if (arguments.Count() == 1 && arguments[0] == type)
+                        {
+                            match = constructor;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return match;
+        }
     }
 
     /// <summary>

src/Chr.Avro/Resolution/DataContractResolver.cs

@@ -72,7 +72,7 @@ public class DataContractResolver : TypeResolver
                 resolver => new DictionaryResolverCase(),
 
                 // enumerables:
-                resolver => new EnumerableResolverCase(),
+                resolver => new EnumerableResolverCase(memberVisibility),
 
                 // built-ins:
                 resolver => new DateTimeResolverCase(),
@@ -278,7 +278,13 @@ public override TypeResolution Resolve(Type type)
                 .Select(m => new FieldResolution(m.MemberInfo, m.Type, m.Name))
                 .ToList();
 
-            return new RecordResolution(type, name, @namespace, fields);
+            var constructors = GetConstructors(type, MemberVisibility)
+                .Select(c => new ConstructorResolution(
+                    c.ConstructorInfo,
+                    c.Parameters.Select(p => new ParameterResolution(p, p.ParameterType, new IdentifierResolution(p.Name))).ToList()
+                )).ToList();
+
+            return new RecordResolution(type, name, @namespace, fields, constructors);
         }
     }
 }

src/Chr.Avro/Resolution/ReflectionResolver.cs

@@ -72,7 +72,7 @@ public class ReflectionResolver : TypeResolver
                 resolver => new DictionaryResolverCase(),
 
                 // enumerables:
-                resolver => new EnumerableResolverCase(),
+                resolver => new EnumerableResolverCase(memberVisibility),
 
                 // built-ins:
                 resolver => new DateTimeResolverCase(),
@@ -347,6 +347,13 @@ public override TypeResolution Resolve(Type type)
     /// </summary>
     public class EnumResolverCase : ReflectionResolverCase
     {
+        /// <summary>
+        /// The binding flags that will be used to select fields and properties.
+        /// </summary>
+        public BindingFlags MemberVisibility { get; }
+
+
+
         /// <summary>
         /// Resolves enum type information.
         /// </summary>
@@ -445,6 +452,22 @@ public override TypeResolution Resolve(Type type)
     /// </summary>
     public class EnumerableResolverCase : ReflectionResolverCase
     {
+        /// <summary>
+        /// The binding flags that will be used to select fields and properties.
+        /// </summary>
+        public BindingFlags MemberVisibility { get; }
+
+        /// <summary>
+        /// Creates a new object resolver case.
+        /// </summary>
+        /// <param name="memberVisibility">
+        /// The binding flags that will be used to select fields and properties.
+        /// </param>
+        public EnumerableResolverCase(BindingFlags memberVisibility)
+        {
+            MemberVisibility = memberVisibility;
+        }
+
         /// <summary>
         /// Resolves enumerable type information.
         /// </summary>
@@ -466,7 +489,18 @@ public override TypeResolution Resolve(Type type)
                 throw new UnsupportedTypeException(type);
             }
 
-            return new ArrayResolution(type, itemType);
+            ICollection<ConstructorResolution> constructors = null;
+
+            if (!type.IsArray)
+            {
+                constructors = GetConstructors(type, MemberVisibility)
+                    .Select(c => new ConstructorResolution(
+                        c.ConstructorInfo,
+                        c.Parameters.Select(p => new ParameterResolution(p, p.ParameterType, new IdentifierResolution(p.Name))).ToList()
+                    )).ToList();
+            }
+
+            return new ArrayResolution(type, itemType, constructors);
         }
     }
 

src/Chr.Avro/Resolution/TypeResolution.cs

@@ -62,8 +62,25 @@ public TypeResolution(Type type, bool isNullable = false)
     /// </summary>
     public class ArrayResolution : TypeResolution
     {
+        private ICollection<ConstructorResolution> constructors;
+
         private Type itemType;
 
+        /// <summary>
+        /// The record constructors.
+        /// </summary>
+        public virtual ICollection<ConstructorResolution> Constructors
+        {
+            get
+            {
+                return constructors ?? throw new InvalidOperationException();
+            }
+            set
+            {
+                constructors = value ?? throw new ArgumentNullException(nameof(value), "Record constructor collection cannot be null.");
+            }
+        }
+
         /// <summary>
         /// The array item type.
         /// </summary>
@@ -97,8 +114,9 @@ public virtual Type ItemType
         /// <exception cref="ArgumentNullException">
         /// Thrown when the array type or the item type is null.
         /// </exception>
-        public ArrayResolution(Type type, Type itemType, bool isNullable = false) : base(type, isNullable)
+        public ArrayResolution(Type type, Type itemType, ICollection<ConstructorResolution> constructors, bool isNullable = false) : base(type, isNullable)
         {
+            Constructors = constructors ?? new ConstructorResolution[0];
             ItemType = itemType;
         }
     }

tests/Chr.Avro.Binary.Tests/ArraySerializationTests.cs

@@ -85,6 +85,17 @@ public void ListValues(int[] value)
             Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value.ToList())));
         }
 
+        [Theory]
+        [MemberData(nameof(ISetData))]
+        public void HashSetValues(HashSet<string> value)
+        {
+            var schema = new ArraySchema(new StringSchema());
+            var deserializer = DeserializerBuilder.BuildDeserializer<HashSet<string>>(schema);
+            var serializer = SerializerBuilder.BuildSerializer<HashSet<string>>(schema);
+
+            Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value)));
+        }
+
         public static IEnumerable<object[]> ArrayData => new List<object[]>
         {
             new object[] { new int[] { } },

tests/Chr.Avro.Binary.Tests/RecordConstructorDeserializationTests.cs

@@ -10,17 +10,14 @@ public class RecordConstructorDeserializationTests
     {
         protected readonly IBinaryDeserializerBuilder DeserializerBuilder;
 
-        protected readonly ITypeResolver TypeResolver;
-
         protected readonly ISchemaBuilder SchemaBuilder;
 
         protected readonly IBinarySerializerBuilder SerializerBuilder;
 
         public RecordConstructorDeserializationTests()
         {
-            TypeResolver = new ReflectionResolver(resolveReferenceTypesAsNullable: true);
-            DeserializerBuilder = new BinaryDeserializerBuilder(resolver: TypeResolver);
-            SchemaBuilder = new SchemaBuilder(typeResolver: TypeResolver);
+            DeserializerBuilder = new BinaryDeserializerBuilder();
+            SchemaBuilder = new SchemaBuilder();
             SerializerBuilder = new BinarySerializerBuilder();
         }