Flexible collection types/interfaces on HasMany attributes

Author: Bart Koelman

src/Examples/GettingStarted/Models/Person.cs

@@ -7,7 +7,8 @@ public sealed class Person : Identifiable
     {
         [Attr] 
         public string Name { get; set; }
+
         [HasMany] 
-        public List<Article> Articles { get; set; }
+        public ICollection<Article> Articles { get; set; }
     }
 }

src/Examples/JsonApiDotNetCoreExample/Models/Author.cs

@@ -9,7 +9,7 @@ public sealed class Author : Identifiable
         public string Name { get; set; }
 
         [HasMany]
-        public List<Article> Articles { get; set; }
+        public IList<Article> Articles { get; set; }
     }
 }
 

src/Examples/JsonApiDotNetCoreExample/Models/Person.cs

@@ -44,13 +44,13 @@ public string FirstName
         public Gender Gender { get; set; }
 
         [HasMany]
-        public List<TodoItem> TodoItems { get; set; }
+        public ISet<TodoItem> TodoItems { get; set; }
 
         [HasMany]
-        public List<TodoItem> AssignedTodoItems { get; set; }
+        public ISet<TodoItem> AssignedTodoItems { get; set; }
 
         [HasMany]
-        public List<TodoItemCollection> todoCollections { get; set; }
+        public HashSet<TodoItemCollection> todoCollections { get; set; }
 
         [HasOne]
         public PersonRole Role { get; set; }

src/Examples/JsonApiDotNetCoreExample/Models/TodoItem.cs

@@ -62,7 +62,7 @@ public string AlwaysChangingValue
         public int? OneToOnePersonId { get; set; }
 
         [HasMany]
-        public List<Person> StakeHolders { get; set; }
+        public ISet<Person> StakeHolders { get; set; }
 
         [HasOne]
         public TodoItemCollection Collection { get; set; }
@@ -80,6 +80,6 @@ public string AlwaysChangingValue
         public TodoItem ParentTodo { get; set; }
 
         [HasMany]
-        public List<TodoItem> ChildrenTodos { get; set; }
+        public IList<TodoItem> ChildrenTodos { get; set; }
     }
 }

src/Examples/JsonApiDotNetCoreExample/Models/TodoItemCollection.cs

@@ -11,7 +11,7 @@ public sealed class TodoItemCollection : Identifiable<Guid>
         public string Name { get; set; }
 
         [HasMany]
-        public List<TodoItem> TodoItems { get; set; }
+        public ISet<TodoItem> TodoItems { get; set; }
 
         [HasOne]
         public Person Owner { get; set; }

src/JsonApiDotNetCore/Data/DefaultResourceRepository.cs

@@ -244,20 +244,22 @@ private object GetTrackedRelationshipValue(RelationshipAttribute relationshipAtt
         }
 
         // helper method used in GetTrackedRelationshipValue. See comments below.
-        private IList GetTrackedManyRelationshipValue(IEnumerable<IIdentifiable> relationshipValueList, RelationshipAttribute relationshipAttr, ref bool wasAlreadyAttached)
+        private IEnumerable GetTrackedManyRelationshipValue(IEnumerable<IIdentifiable> relationshipValueList, RelationshipAttribute relationshipAttr, ref bool wasAlreadyAttached)
         {
             if (relationshipValueList == null) return null;
             bool newWasAlreadyAttached = false;
             var trackedPointerCollection = relationshipValueList.Select(pointer =>
-                {   // convert each element in the value list to relationshipAttr.DependentType.
+                {
+                    // convert each element in the value list to relationshipAttr.DependentType.
                     var tracked = AttachOrGetTracked(pointer);
                     if (tracked != null) newWasAlreadyAttached = true;
                     return Convert.ChangeType(tracked ?? pointer, relationshipAttr.RightType);
                 })
                 .ToList()
-                .Cast(relationshipAttr.RightType);
+                .CopyToTypedCollection(relationshipAttr.PropertyInfo.PropertyType);
+
             if (newWasAlreadyAttached) wasAlreadyAttached = true;
-            return (IList)trackedPointerCollection;
+            return trackedPointerCollection;
         }
 
         // helper method used in GetTrackedRelationshipValue. See comments there.

src/JsonApiDotNetCore/Extensions/QueryableExtensions.cs

@@ -377,15 +377,14 @@ private static IQueryable<TSource> CallGenericSelectMethod<TSource>(IQueryable<T
                 Expression bindExpression;
                 if (nestedPropertyType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(nestedPropertyType))
                 {
-                    // Concrete type of Collection
-                    var singleType = nestedPropertyType.GetGenericArguments().Single();
+                    var collectionElementType = nestedPropertyType.GetGenericArguments().Single();
                     // {y}
-                    var nestedParameter = Expression.Parameter(singleType, "y");
+                    var nestedParameter = Expression.Parameter(collectionElementType, "y");
                     nestedBindings = item.Value.Select(prop => Expression.Bind(
-                        singleType.GetProperty(prop), Expression.PropertyOrField(nestedParameter, prop))).ToList();
+                        collectionElementType.GetProperty(prop), Expression.PropertyOrField(nestedParameter, prop))).ToList();
 
                     // { new Item() }
-                    var newNestedExp = Expression.New(singleType);
+                    var newNestedExp = Expression.New(collectionElementType);
                     var initNestedExp = Expression.MemberInit(newNestedExp, nestedBindings);
                     // { y => new Item() {Id = y.Id, Name = y.Name}}
                     var body = Expression.Lambda(initNestedExp, nestedParameter);
@@ -395,15 +394,15 @@ private static IQueryable<TSource> CallGenericSelectMethod<TSource>(IQueryable<T
                     Expression selectMethod = Expression.Call(
                         typeof(Enumerable),
                         "Select",
-                        new[] { singleType, singleType },
+                        new[] { collectionElementType, collectionElementType },
                         propertyExpression, body);
 
-                    // { x.Items.Select(y => new Item() {Id = y.Id, Name = y.Name}).ToList() }
-                    bindExpression = Expression.Call(
-                         typeof(Enumerable),
-                         "ToList",
-                         new[] { singleType },
-                         selectMethod);
+                    var enumerableOfElementType = typeof(IEnumerable<>).MakeGenericType(collectionElementType);
+                    var typedCollection = nestedPropertyType.ToConcreteCollectionType();
+                    var typedCollectionConstructor = typedCollection.GetConstructor(new[] {enumerableOfElementType});
+
+                    // { new HashSet<Item>(x.Items.Select(y => new Item() {Id = y.Id, Name = y.Name})) }
+                    bindExpression = Expression.New(typedCollectionConstructor, selectMethod);
                 }
                 // [HasOne] attribute
                 else

src/JsonApiDotNetCore/Extensions/TypeExtensions.cs

@@ -3,6 +3,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using JsonApiDotNetCore.Models;
 
 namespace JsonApiDotNetCore.Extensions
@@ -13,10 +14,10 @@ internal static class TypeExtensions
         /// Extension to use the LINQ cast method in a non-generic way:
         /// <code>
         /// Type targetType = typeof(TResource)
-        /// ((IList)myList).Cast(targetType).
+        /// ((IList)myList).CopyToList(targetType).
         /// </code>
         /// </summary>
-        public static IEnumerable Cast(this IEnumerable source, Type type)
+        public static IEnumerable CopyToList(this IEnumerable source, Type type)
         {
             if (source == null) throw new ArgumentNullException(nameof(source));
             if (type == null) throw new ArgumentNullException(nameof(type));
@@ -29,6 +30,28 @@ public static IEnumerable Cast(this IEnumerable source, Type type)
             return list;
         }
 
+        /// <summary>
+        /// Creates a collection instance based on the specified collection type and copies the specified elements into it.
+        /// </summary>
+        /// <param name="source">Source to copy from.</param>
+        /// <param name="collectionType">Target collection type, for example: typeof(List{Article}) or typeof(ISet{Person}).</param>
+        /// <returns></returns>
+        public static IEnumerable CopyToTypedCollection(this IEnumerable source, Type collectionType)
+        {
+            if (source == null) throw new ArgumentNullException(nameof(source));
+            if (collectionType == null) throw new ArgumentNullException(nameof(collectionType));
+
+            var concreteCollectionType = collectionType.ToConcreteCollectionType();
+            dynamic concreteCollectionInstance = concreteCollectionType.New<dynamic>();
+
+            foreach (var item in source)
+            {
+                concreteCollectionInstance.Add((dynamic) item);
+            }
+
+            return concreteCollectionInstance;
+        }
+
         /// <summary>
         /// Creates a List{TInterface} where TInterface is the generic for type specified by t
         /// </summary>
@@ -99,5 +122,10 @@ public static bool Inherits<T>(this Type concreteType)
         /// </summary>
         public static bool Inherits(this Type concreteType, Type interfaceType) 
             => interfaceType?.IsAssignableFrom(concreteType) == true;
+
+        public static bool ImplementsInterface(this Type source, Type interfaceType)
+        {
+            return source.GetInterfaces().Any(type => type == interfaceType);
+        }
     }
 }

src/JsonApiDotNetCore/Hooks/Execution/DiffableEntityHashSet.cs

@@ -75,7 +75,11 @@ public IEnumerable<EntityDiffPair<TResource>> GetDiffs()
         {
             var propertyInfo = TypeHelper.ParseNavigationExpression(navigationAction);
             var propertyType = propertyInfo.PropertyType;
-            if (propertyType.Inherits(typeof(IEnumerable))) propertyType = TypeHelper.GetTypeOfList(propertyType);
+            if (propertyType.ImplementsInterface(typeof(IEnumerable)))
+            {
+                propertyType = TypeHelper.TryGetCollectionElementType(propertyType);
+            }
+
             if (propertyType.Implements<IIdentifiable>())
             {
                 // the navigation action references a relationship. Redirect the call to the relationship dictionary. 

src/JsonApiDotNetCore/Hooks/Execution/HookExecutorHelper.cs

@@ -81,10 +81,10 @@ public IEnumerable LoadDbValues(LeftType entityTypeForRepository, IEnumerable en
                     .GetMethod(nameof(GetWhereAndInclude), BindingFlags.NonPublic | BindingFlags.Instance)
                     .MakeGenericMethod(entityTypeForRepository, idType);
             var cast = ((IEnumerable<object>)entities).Cast<IIdentifiable>();
-            var ids = cast.Select(e => e.StringId).Cast(idType);
+            var ids = cast.Select(e => e.StringId).CopyToList(idType);
             var values = (IEnumerable)parameterizedGetWhere.Invoke(this, new object[] { ids, relationshipsToNextLayer });
             if (values == null) return null;
-            return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(entityTypeForRepository), values.Cast(entityTypeForRepository));
+            return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(entityTypeForRepository), values.CopyToList(entityTypeForRepository));
         }
 
         public HashSet<TResource> LoadDbValues<TResource>(IEnumerable<TResource> entities, ResourceHook hook, params RelationshipAttribute[] relationships) where TResource : class, IIdentifiable