Refactored TypeHelper

Author: Bart Koelman

src/Examples/JsonApiDotNetCoreExample/Definitions/PassportHooksDefinition.cs

@@ -31,7 +31,7 @@ public override void BeforeRead(ResourcePipeline pipeline, bool isIncluded = fal
 
         public override void BeforeImplicitUpdateRelationship(IRelationshipsDictionary<Passport> resourcesByRelationship, ResourcePipeline pipeline)
         {
-            resourcesByRelationship.GetByRelationship<Person>().ToList().ForEach(kvp => DisallowLocked(kvp.Value));
+            resourcesByRelationship.GetByRelationship<Person>().ToList().ForEach(pair => DisallowLocked(pair.Value));
         }
 
         public override IEnumerable<Passport> OnReturn(HashSet<Passport> resources, ResourcePipeline pipeline)

src/Examples/JsonApiDotNetCoreExample/Definitions/PersonHooksDefinition.cs

@@ -24,7 +24,7 @@ public override IEnumerable<string> BeforeUpdateRelationship(HashSet<string> ids
 
         public override void BeforeImplicitUpdateRelationship(IRelationshipsDictionary<Person> resourcesByRelationship, ResourcePipeline pipeline)
         {
-            resourcesByRelationship.GetByRelationship<Passport>().ToList().ForEach(kvp => DisallowLocked(kvp.Value));
+            resourcesByRelationship.GetByRelationship<Passport>().ToList().ForEach(pair => DisallowLocked(pair.Value));
         }
     }
 }

src/Examples/JsonApiDotNetCoreExample/Definitions/TodoItemHooksDefinition.cs

@@ -31,7 +31,7 @@ public override void BeforeRead(ResourcePipeline pipeline, bool isIncluded = fal
 
         public override void BeforeImplicitUpdateRelationship(IRelationshipsDictionary<TodoItem> resourcesByRelationship, ResourcePipeline pipeline)
         {
-            List<TodoItem> todoItems = resourcesByRelationship.GetByRelationship<Person>().SelectMany(kvp => kvp.Value).ToList();
+            List<TodoItem> todoItems = resourcesByRelationship.GetByRelationship<Person>().SelectMany(pair => pair.Value).ToList();
             DisallowLocked(todoItems);
         }
 

src/JsonApiDotNetCore/AtomicOperations/Processors/SetRelationshipProcessor.cs

@@ -14,6 +14,7 @@ namespace JsonApiDotNetCore.AtomicOperations.Processors
     public class SetRelationshipProcessor<TResource, TId> : ISetRelationshipProcessor<TResource, TId>
         where TResource : class, IIdentifiable<TId>
     {
+        private readonly CollectionConverter _collectionConverter = new CollectionConverter();
         private readonly ISetRelationshipService<TResource, TId> _service;
 
         public SetRelationshipProcessor(ISetRelationshipService<TResource, TId> service)
@@ -36,14 +37,14 @@ public virtual async Task<OperationContainer> ProcessAsync(OperationContainer op
             return null;
         }
 
-        private static object GetRelationshipRightValue(OperationContainer operation)
+        private object GetRelationshipRightValue(OperationContainer operation)
         {
             RelationshipAttribute relationship = operation.Request.Relationship;
             object rightValue = relationship.GetValue(operation.Resource);
 
             if (relationship is HasManyAttribute)
             {
-                ICollection<IIdentifiable> rightResources = TypeHelper.ExtractResources(rightValue);
+                ICollection<IIdentifiable> rightResources = _collectionConverter.ExtractResources(rightValue);
                 return rightResources.ToHashSet(IdentifiableComparer.Instance);
             }
 

src/JsonApiDotNetCore/CollectionConverter.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using JsonApiDotNetCore.Resources;
+
+namespace JsonApiDotNetCore
+{
+    internal class CollectionConverter
+    {
+        private static readonly Type[] HashSetCompatibleCollectionTypes =
+        {
+            typeof(HashSet<>),
+            typeof(ICollection<>),
+            typeof(ISet<>),
+            typeof(IEnumerable<>),
+            typeof(IReadOnlyCollection<>)
+        };
+
+        /// <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>
+        public IEnumerable CopyToTypedCollection(IEnumerable source, Type collectionType)
+        {
+            ArgumentGuard.NotNull(source, nameof(source));
+            ArgumentGuard.NotNull(collectionType, nameof(collectionType));
+
+            Type concreteCollectionType = ToConcreteCollectionType(collectionType);
+            dynamic concreteCollectionInstance = Activator.CreateInstance(concreteCollectionType);
+
+            foreach (object item in source)
+            {
+                concreteCollectionInstance!.Add((dynamic)item);
+            }
+
+            return concreteCollectionInstance;
+        }
+
+        /// <summary>
+        /// Returns a compatible collection type that can be instantiated, for example IList{Article} -> List{Article} or ISet{Article} -> HashSet{Article}
+        /// </summary>
+        public Type ToConcreteCollectionType(Type collectionType)
+        {
+            if (collectionType.IsInterface && collectionType.IsGenericType)
+            {
+                Type genericTypeDefinition = collectionType.GetGenericTypeDefinition();
+
+                if (genericTypeDefinition == typeof(ICollection<>) || genericTypeDefinition == typeof(ISet<>) ||
+                    genericTypeDefinition == typeof(IEnumerable<>) || genericTypeDefinition == typeof(IReadOnlyCollection<>))
+                {
+                    return typeof(HashSet<>).MakeGenericType(collectionType.GenericTypeArguments[0]);
+                }
+
+                if (genericTypeDefinition == typeof(IList<>) || genericTypeDefinition == typeof(IReadOnlyList<>))
+                {
+                    return typeof(List<>).MakeGenericType(collectionType.GenericTypeArguments[0]);
+                }
+            }
+
+            return collectionType;
+        }
+
+        /// <summary>
+        /// Returns a collection that contains zero, one or multiple resources, depending on the specified value.
+        /// </summary>
+        public ICollection<IIdentifiable> ExtractResources(object value)
+        {
+            if (value is ICollection<IIdentifiable> resourceCollection)
+            {
+                return resourceCollection;
+            }
+
+            if (value is IEnumerable<IIdentifiable> resources)
+            {
+                return resources.ToList();
+            }
+
+            if (value is IIdentifiable resource)
+            {
+                return resource.AsArray();
+            }
+
+            return Array.Empty<IIdentifiable>();
+        }
+
+        /// <summary>
+        /// Returns the element type if the specified type is a generic collection, for example: IList{string} -> string or IList -> null.
+        /// </summary>
+        public Type TryGetCollectionElementType(Type type)
+        {
+            if (type != null)
+            {
+                if (type.IsGenericType && type.GenericTypeArguments.Length == 1)
+                {
+                    if (type.IsOrImplementsInterface(typeof(IEnumerable)))
+                    {
+                        return type.GenericTypeArguments[0];
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Indicates whether a <see cref="HashSet{T}" /> instance can be assigned to the specified type, for example IList{Article} -> false or ISet{Article} ->
+        /// true.
+        /// </summary>
+        public bool TypeCanContainHashSet(Type collectionType)
+        {
+            if (collectionType.IsGenericType)
+            {
+                Type openCollectionType = collectionType.GetGenericTypeDefinition();
+                return HashSetCompatibleCollectionTypes.Contains(openCollectionType);
+            }
+
+            return false;
+        }
+    }
+}

src/JsonApiDotNetCore/Configuration/ResourceGraphBuilder.cs

@@ -108,7 +108,7 @@ public ResourceGraphBuilder Add(Type resourceType, Type idType = null, string pu
                 return this;
             }
 
-            if (TypeHelper.IsOrImplementsInterface(resourceType, typeof(IIdentifiable)))
+            if (resourceType.IsOrImplementsInterface(typeof(IIdentifiable)))
             {
                 string effectivePublicName = publicName ?? FormatResourceName(resourceType);
                 Type effectiveIdType = idType ?? _typeLocator.TryGetIdType(resourceType);
@@ -288,7 +288,7 @@ private Type TryGetThroughType(PropertyInfo throughProperty)
                 {
                     Type constructedThroughType = typeof(ICollection<>).MakeGenericType(typeArguments[0]);
 
-                    if (TypeHelper.IsOrImplementsInterface(throughProperty.PropertyType, constructedThroughType))
+                    if (throughProperty.PropertyType.IsOrImplementsInterface(constructedThroughType))
                     {
                         return typeArguments[0];
                     }

src/JsonApiDotNetCore/Configuration/TypeLocator.cs

@@ -27,7 +27,7 @@ public Type TryGetIdType(Type resourceType)
         /// </summary>
         public ResourceDescriptor TryGetResourceDescriptor(Type type)
         {
-            if (TypeHelper.IsOrImplementsInterface(type, typeof(IIdentifiable)))
+            if (type.IsOrImplementsInterface(typeof(IIdentifiable)))
             {
                 Type idType = TryGetIdType(type);
 

src/JsonApiDotNetCore/Hooks/Internal/Execution/DiffableResourceHashSet.cs

@@ -15,6 +15,9 @@ namespace JsonApiDotNetCore.Hooks.Internal.Execution
     public sealed class DiffableResourceHashSet<TResource> : ResourceHashSet<TResource>, IDiffableResourceHashSet<TResource>
         where TResource : class, IIdentifiable
     {
+        // ReSharper disable once StaticMemberInGenericType
+        private static readonly CollectionConverter CollectionConverter = new CollectionConverter();
+
         private readonly HashSet<TResource> _databaseValues;
         private readonly bool _databaseValuesLoaded;
         private readonly IDictionary<PropertyInfo, HashSet<TResource>> _updatedAttributes;
@@ -59,15 +62,15 @@ public override HashSet<TResource> GetAffected(Expression<Func<TResource, object
         {
             ArgumentGuard.NotNull(navigationAction, nameof(navigationAction));
 
-            PropertyInfo propertyInfo = TypeHelper.ParseNavigationExpression(navigationAction);
+            PropertyInfo propertyInfo = HooksNavigationParser.ParseNavigationExpression(navigationAction);
             Type propertyType = propertyInfo.PropertyType;
 
-            if (TypeHelper.IsOrImplementsInterface(propertyType, typeof(IEnumerable)))
+            if (propertyType.IsOrImplementsInterface(typeof(IEnumerable)))
             {
-                propertyType = TypeHelper.TryGetCollectionElementType(propertyType);
+                propertyType = CollectionConverter.TryGetCollectionElementType(propertyType);
             }
 
-            if (TypeHelper.IsOrImplementsInterface(propertyType, typeof(IIdentifiable)))
+            if (propertyType.IsOrImplementsInterface(typeof(IIdentifiable)))
             {
                 // the navigation action references a relationship. Redirect the call to the relationship dictionary.
                 return base.GetAffected(navigationAction);

src/JsonApiDotNetCore/Hooks/Internal/Execution/HookExecutorHelper.cs

@@ -19,20 +19,22 @@ namespace JsonApiDotNetCore.Hooks.Internal.Execution
     /// <inheritdoc />
     internal sealed class HookExecutorHelper : IHookExecutorHelper
     {
+        private static readonly HooksCollectionConverter CollectionConverter = new HooksCollectionConverter();
+        private static readonly HooksObjectFactory ObjectFactory = new HooksObjectFactory();
         private static readonly IncludeChainConverter IncludeChainConverter = new IncludeChainConverter();
 
         private readonly IdentifiableComparer _comparer = IdentifiableComparer.Instance;
         private readonly IJsonApiOptions _options;
-        private readonly IGenericServiceFactory _genericProcessorFactory;
+        private readonly IGenericServiceFactory _genericServiceFactory;
         private readonly IResourceContextProvider _resourceContextProvider;
         private readonly Dictionary<RightType, IResourceHookContainer> _hookContainers;
         private readonly Dictionary<RightType, IHooksDiscovery> _hookDiscoveries;
         private readonly List<ResourceHook> _targetedHooksForRelatedResources;
 
-        public HookExecutorHelper(IGenericServiceFactory genericProcessorFactory, IResourceContextProvider resourceContextProvider, IJsonApiOptions options)
+        public HookExecutorHelper(IGenericServiceFactory genericServiceFactory, IResourceContextProvider resourceContextProvider, IJsonApiOptions options)
         {
             _options = options;
-            _genericProcessorFactory = genericProcessorFactory;
+            _genericServiceFactory = genericServiceFactory;
             _resourceContextProvider = resourceContextProvider;
             _hookContainers = new Dictionary<RightType, IResourceHookContainer>();
             _hookDiscoveries = new Dictionary<RightType, IHooksDiscovery>();
@@ -48,7 +50,7 @@ public IResourceHookContainer GetResourceHookContainer(RightType targetResource,
             // so we need not even bother.
             if (!_hookContainers.TryGetValue(targetResource, out IResourceHookContainer container))
             {
-                container = _genericProcessorFactory.Get<IResourceHookContainer>(typeof(ResourceHooksDefinition<>), targetResource);
+                container = _genericServiceFactory.Get<IResourceHookContainer>(typeof(ResourceHooksDefinition<>), targetResource);
                 _hookContainers[targetResource] = container;
             }
 
@@ -91,23 +93,17 @@ public IResourceHookContainer<TResource> GetResourceHookContainer<TResource>(Res
 
         public IEnumerable LoadDbValues(LeftType resourceTypeForRepository, IEnumerable resources, params RelationshipAttribute[] relationshipsToNextLayer)
         {
-            LeftType idType = TypeHelper.GetIdType(resourceTypeForRepository);
+            LeftType idType = ObjectFactory.GetIdType(resourceTypeForRepository);
 
             MethodInfo parameterizedGetWhere =
                 GetType().GetMethod(nameof(GetWhereWithInclude), BindingFlags.NonPublic | BindingFlags.Instance)!.MakeGenericMethod(resourceTypeForRepository,
                     idType);
 
-            IEnumerable<IIdentifiable> cast = ((IEnumerable<object>)resources).Cast<IIdentifiable>();
-            IList ids = TypeHelper.CopyToList(cast.Select(resource => resource.GetTypedId()), idType);
-            var values = (IEnumerable)parameterizedGetWhere.Invoke(this, ArrayFactory.Create<object>(ids, relationshipsToNextLayer));
+            IEnumerable<object> resourceIds = ((IEnumerable<object>)resources).Cast<IIdentifiable>().Select(resource => resource.GetTypedId());
+            IList idsAsList = CollectionConverter.CopyToList(resourceIds, idType);
+            var values = (IEnumerable)parameterizedGetWhere.Invoke(this, ArrayFactory.Create<object>(idsAsList, relationshipsToNextLayer));
 
-            if (values == null)
-            {
-                return null;
-            }
-
-            return (IEnumerable)Activator.CreateInstance(typeof(HashSet<>).MakeGenericType(resourceTypeForRepository),
-                TypeHelper.CopyToList(values, resourceTypeForRepository));
+            return values == null ? null : CollectionConverter.CopyToHashSet(values, resourceTypeForRepository);
         }
 
         public bool ShouldLoadDbValues(LeftType resourceType, ResourceHook hook)
@@ -146,7 +142,7 @@ private IHooksDiscovery GetHookDiscovery(LeftType resourceType)
         {
             if (!_hookDiscoveries.TryGetValue(resourceType, out IHooksDiscovery discovery))
             {
-                discovery = _genericProcessorFactory.Get<IHooksDiscovery>(typeof(IHooksDiscovery<>), resourceType);
+                discovery = _genericServiceFactory.Get<IHooksDiscovery>(typeof(IHooksDiscovery<>), resourceType);
                 _hookDiscoveries[resourceType] = discovery;
             }
 
@@ -199,7 +195,7 @@ private static FilterExpression CreateFilterByIds<TId>(IReadOnlyCollection<TId>
         private IResourceReadRepository<TResource, TId> GetRepository<TResource, TId>()
             where TResource : class, IIdentifiable<TId>
         {
-            return _genericProcessorFactory.Get<IResourceReadRepository<TResource, TId>>(typeof(IResourceReadRepository<,>), typeof(TResource), typeof(TId));
+            return _genericServiceFactory.Get<IResourceReadRepository<TResource, TId>>(typeof(IResourceReadRepository<,>), typeof(TResource), typeof(TId));
         }
 
         public IDictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(IDictionary<RelationshipAttribute, IEnumerable> leftResourcesByRelation,
@@ -209,10 +205,10 @@ public IDictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(ID
 
             var implicitlyAffected = new Dictionary<RelationshipAttribute, IEnumerable>();
 
-            foreach (KeyValuePair<RelationshipAttribute, IEnumerable> kvp in leftResourcesByRelation)
+            foreach (KeyValuePair<RelationshipAttribute, IEnumerable> pair in leftResourcesByRelation)
             {
-                RelationshipAttribute relationship = kvp.Key;
-                IEnumerable lefts = kvp.Value;
+                RelationshipAttribute relationship = pair.Key;
+                IEnumerable lefts = pair.Value;
 
                 if (relationship is HasManyThroughAttribute)
                 {
@@ -225,45 +221,31 @@ public IDictionary<RelationshipAttribute, IEnumerable> LoadImplicitlyAffected(ID
                 AddToImplicitlyAffected(includedLefts, relationship, existingRightResourceList, implicitlyAffected);
             }
 
-            return implicitlyAffected.ToDictionary(kvp => kvp.Key, kvp => TypeHelper.CreateHashSetFor(kvp.Key.RightType, kvp.Value));
+            return implicitlyAffected.ToDictionary(pair => pair.Key, pair => CollectionConverter.CopyToHashSet(pair.Value, pair.Key.RightType));
         }
 
         private void AddToImplicitlyAffected(IEnumerable includedLefts, RelationshipAttribute relationship, List<IIdentifiable> existingRightResourceList,
             Dictionary<RelationshipAttribute, IEnumerable> implicitlyAffected)
         {
             foreach (IIdentifiable ip in includedLefts)
             {
-                IList dbRightResourceList = TypeHelper.CreateListFor(relationship.RightType);
                 object relationshipValue = relationship.GetValue(ip);
-
-                if (!(relationshipValue is IEnumerable))
-                {
-                    if (relationshipValue != null)
-                    {
-                        dbRightResourceList.Add(relationshipValue);
-                    }
-                }
-                else
-                {
-                    AddToList(dbRightResourceList, (IEnumerable)relationshipValue);
-                }
-
-                List<IIdentifiable> dbRightResourceListCast = dbRightResourceList.Cast<IIdentifiable>().ToList();
+                ICollection<IIdentifiable> dbRightResources = CollectionConverter.ExtractResources(relationshipValue);
 
                 if (existingRightResourceList != null)
                 {
-                    dbRightResourceListCast = dbRightResourceListCast.Except(existingRightResourceList, _comparer).ToList();
+                    dbRightResources = dbRightResources.Except(existingRightResourceList, _comparer).ToList();
                 }
 
-                if (dbRightResourceListCast.Any())
+                if (dbRightResources.Any())
                 {
                     if (!implicitlyAffected.TryGetValue(relationship, out IEnumerable affected))
                     {
-                        affected = TypeHelper.CreateListFor(relationship.RightType);
+                        affected = CollectionConverter.CopyToList(Array.Empty<object>(), relationship.RightType);
                         implicitlyAffected[relationship] = affected;
                     }
 
-                    AddToList((IList)affected, dbRightResourceListCast);
+                    AddToList((IList)affected, dbRightResources);
                 }
             }
         }